Skip to content
This repository was archived by the owner on Jun 5, 2025. It is now read-only.

Commit a8fc230

Browse files
marcos-albornozmarcos-albornoz
committed
fix: add missing tests to test VCertTknClient SDK methods
1 parent bafc48a commit a8fc230

5 files changed

Lines changed: 516 additions & 0 deletions

File tree

‎src/test/java/com/venafi/vcert/sdk/vcertTknClient/VCertTknClientAT.java‎

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,87 @@
1+
package com.venafi.vcert.sdk.vcertTknClient;
2+
3+
import static com.venafi.vcert.sdk.TestUtils.getTestIps;
4+
import static java.lang.String.format;
5+
import static org.assertj.core.api.Assertions.assertThat;
6+
import static org.assertj.core.api.Assertions.assertThatCode;
7+
import static org.junit.jupiter.api.Assertions.assertThrows;
8+
9+
import java.io.IOException;
10+
import java.io.StringReader;
11+
import java.net.InetAddress;
12+
import java.util.Arrays;
13+
import java.util.Collections;
14+
15+
import org.bouncycastle.openssl.PEMParser;
16+
import org.bouncycastle.pkcs.PKCS10CertificationRequest;
17+
import org.junit.jupiter.api.Test;
18+
import org.junit.jupiter.api.extension.RegisterExtension;
19+
20+
import com.venafi.vcert.sdk.TestUtils;
21+
import com.venafi.vcert.sdk.VCertException;
22+
import com.venafi.vcert.sdk.certificate.CertificateRequest;
23+
import com.venafi.vcert.sdk.certificate.KeyType;
24+
import com.venafi.vcert.sdk.connectors.ZoneConfiguration;
25+
26+
import feign.FeignException;
27+
28+
class VCertTknClientAT {
29+
30+
@RegisterExtension
31+
public static final VCertTknClientResource clientResource = new VCertTknClientResource();
32+
33+
@Test
34+
void readZoneConfiguration() throws VCertException {
35+
try {
36+
clientResource.client().readZoneConfiguration(TestUtils.TPP_ZONE);
37+
} catch (FeignException fe) {
38+
throw VCertException.fromFeignException(fe);
39+
}
40+
}
41+
42+
@Test
43+
void readZoneConfigurationInLongFormat() throws VCertException {
44+
try {
45+
clientResource.client().readZoneConfiguration("\\VED\\Policy\\"+TestUtils.TPP_ZONE);
46+
} catch (FeignException fe) {
47+
throw VCertException.fromFeignException(fe);
48+
}
49+
}
50+
51+
@Test
52+
void ping() throws VCertException {
53+
assertThatCode(() -> clientResource.client().ping()).doesNotThrowAnyException();
54+
}
55+
56+
@Test
57+
void generateRequest() throws VCertException, IOException {
58+
String commonName = TestUtils.randomCN();
59+
ZoneConfiguration zoneConfiguration = clientResource.client().readZoneConfiguration(TestUtils.TPP_ZONE);
60+
CertificateRequest certificateRequest = new CertificateRequest()
61+
.subject(new CertificateRequest.PKIXName().commonName(commonName)
62+
.organization(Collections.singletonList("Venafi, Inc."))
63+
.organizationalUnit(Arrays.asList("Engineering", "Automated Tests"))
64+
.country(Collections.singletonList("US")).locality(Collections.singletonList("SLC"))
65+
.province(Collections.singletonList("Utah")))
66+
.dnsNames(Collections.singletonList(InetAddress.getLocalHost().getHostName()))
67+
.ipAddresses(getTestIps()).keyType(KeyType.RSA).keyLength(2048);
68+
69+
certificateRequest = clientResource.client().generateRequest(zoneConfiguration, certificateRequest);
70+
71+
assertThat(certificateRequest.csr()).isNotEmpty();
72+
73+
PKCS10CertificationRequest request = (PKCS10CertificationRequest) new PEMParser(
74+
new StringReader(new String(certificateRequest.csr()))).readObject();
75+
76+
// Values overridden by policy which is why they don't match the above values
77+
String subject = request.getSubject().toString();
78+
79+
assertThat(subject).contains(format("CN=%s", commonName));
80+
}
81+
82+
@Test
83+
void readPolicyConfiguration() {
84+
assertThrows(UnsupportedOperationException.class,
85+
() -> clientResource.client().readPolicyConfiguration("zone"));
86+
}
87+
}

‎src/test/java/com/venafi/vcert/sdk/vcertTknClient/VCertTknClientCertAT.java‎

Lines changed: 267 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,267 @@
1+
/**
2+
*
3+
*/
4+
package com.venafi.vcert.sdk.vcertTknClient;
5+
6+
import static org.assertj.core.api.Assertions.assertThat;
7+
import static org.junit.Assert.assertTrue;
8+
9+
import java.io.IOException;
10+
import java.io.StringReader;
11+
import java.net.SocketException;
12+
import java.net.UnknownHostException;
13+
import java.security.NoSuchAlgorithmException;
14+
import java.security.cert.CertificateException;
15+
import java.security.cert.X509Certificate;
16+
import java.util.ArrayList;
17+
import java.util.List;
18+
19+
import org.apache.commons.codec.digest.DigestUtils;
20+
import org.bouncycastle.util.io.pem.PemHeader;
21+
import org.bouncycastle.util.io.pem.PemObject;
22+
import org.bouncycastle.util.io.pem.PemReader;
23+
import org.junit.jupiter.api.DisplayName;
24+
import org.junit.jupiter.api.Test;
25+
import org.junit.jupiter.api.extension.RegisterExtension;
26+
27+
import com.venafi.vcert.sdk.TestUtils;
28+
import com.venafi.vcert.sdk.VCertException;
29+
import com.venafi.vcert.sdk.VCertTknClient;
30+
import com.venafi.vcert.sdk.certificate.CertificateRequest;
31+
import com.venafi.vcert.sdk.certificate.CsrOriginOption;
32+
import com.venafi.vcert.sdk.certificate.CustomField;
33+
import com.venafi.vcert.sdk.certificate.DataFormat;
34+
import com.venafi.vcert.sdk.certificate.ImportRequest;
35+
import com.venafi.vcert.sdk.certificate.ImportResponse;
36+
import com.venafi.vcert.sdk.certificate.PEMCollection;
37+
import com.venafi.vcert.sdk.certificate.RenewalRequest;
38+
import com.venafi.vcert.sdk.certificate.RevocationRequest;
39+
import com.venafi.vcert.sdk.connectors.ZoneConfiguration;
40+
41+
/**
42+
* @author Marcos E. Albornoz Abud
43+
*
44+
*/
45+
public class VCertTknClientCertAT {
46+
47+
@RegisterExtension
48+
public static final VCertTknClientCertResource clientResource = new VCertTknClientCertResource();
49+
50+
@Test
51+
void requestCertificate() throws VCertException, SocketException, UnknownHostException {
52+
VCertTknClient client = clientResource.client();
53+
ZoneConfiguration zoneConfiguration = clientResource.zoneConfiguration();
54+
55+
CertificateRequest certificateRequest = client.generateRequest(zoneConfiguration, clientResource.certificateRequest());
56+
CertificateRequest csrRequestOnly = new CertificateRequest().csr(certificateRequest.csr());
57+
assertThat(client.requestCertificate(csrRequestOnly, zoneConfiguration)).isNotNull();
58+
}
59+
60+
@Test
61+
void retrieveCertificate() throws VCertException, SocketException, UnknownHostException {
62+
VCertTknClient client = clientResource.client();
63+
ZoneConfiguration zoneConfiguration = clientResource.zoneConfiguration();
64+
CertificateRequest certificateRequest = clientResource.certificateRequest()
65+
//.keyType(KeyType.ECDSA).keyCurve(EllipticCurve.EllipticCurveP521)
66+
//.keyType(KeyType.RSA).keyLength(2048)
67+
//.dataFormat(DataFormat.LEGACY)
68+
//.keyPassword("newtiran000!")
69+
//.csrOrigin(CsrOriginOption.ServiceGeneratedCSR)
70+
;
71+
72+
certificateRequest = client.generateRequest(zoneConfiguration, certificateRequest);
73+
String certificateId = client.requestCertificate(certificateRequest, zoneConfiguration);
74+
75+
assertThat(certificateId).isNotNull();
76+
77+
PEMCollection pemCollection = client.retrieveCertificate(certificateRequest);
78+
79+
assertThat(pemCollection.certificate()).isNotNull();
80+
assertThat(pemCollection.privateKey()).isNotNull();
81+
}
82+
83+
@Test
84+
void renewCertificate() throws VCertException, UnknownHostException, SocketException,
85+
CertificateException, NoSuchAlgorithmException {
86+
87+
VCertTknClient client = clientResource.client();
88+
ZoneConfiguration zoneConfiguration = clientResource.zoneConfiguration();
89+
CertificateRequest certificateRequest = client.generateRequest(zoneConfiguration, clientResource.certificateRequest());
90+
String certificateId = client.requestCertificate(certificateRequest, zoneConfiguration);
91+
assertThat(certificateId).isNotNull();
92+
93+
PEMCollection pemCollection = client.retrieveCertificate(certificateRequest);
94+
X509Certificate cert = (X509Certificate) pemCollection.certificate();
95+
96+
String thumbprint = DigestUtils.sha1Hex(cert.getEncoded()).toUpperCase();
97+
98+
CertificateRequest certificateRequestToRenew = new CertificateRequest()
99+
.subject(certificateRequest.subject())
100+
.dnsNames(certificateRequest.dnsNames())
101+
.ipAddresses(certificateRequest.ipAddresses())
102+
.keyType(certificateRequest.keyType())
103+
.keyLength(certificateRequest.keyLength());
104+
client.generateRequest(zoneConfiguration, certificateRequestToRenew);
105+
106+
String renewRequestId = client.renewCertificate(
107+
new RenewalRequest().request(certificateRequestToRenew).thumbprint(thumbprint));
108+
109+
assertThat(renewRequestId).isNotNull();
110+
}
111+
112+
@Test
113+
void revokeCertificate() throws VCertException, SocketException, UnknownHostException {
114+
VCertTknClient client = clientResource.client();
115+
ZoneConfiguration zoneConfiguration = clientResource.zoneConfiguration();
116+
117+
CertificateRequest certificateRequest = client.generateRequest(zoneConfiguration, clientResource.certificateRequest());
118+
String certificateId = client.requestCertificate(certificateRequest, zoneConfiguration);
119+
assertThat(certificateId).isNotNull();
120+
121+
// just wait for the certificate issuance
122+
client.retrieveCertificate(certificateRequest);
123+
124+
RevocationRequest revocationRequest = new RevocationRequest();
125+
revocationRequest.reason("key-compromise");
126+
revocationRequest.certificateDN(certificateRequest.pickupId());
127+
128+
client.revokeCertificate(revocationRequest);
129+
}
130+
131+
@Test
132+
@DisplayName("VCertTknClient - Create a cerfiticate that contais custom fields and validate if certifcate were created correctly")
133+
void createCertificateValidateValidityHours() throws UnknownHostException, VCertException {
134+
135+
//Custom fields
136+
List<CustomField> customFields = new ArrayList<CustomField>();
137+
customFields.add(new CustomField("custom", "java-test"));
138+
customFields.add(new CustomField("cfList", "item2"));
139+
customFields.add(new CustomField("cfListMulti", "tier1"));
140+
customFields.add(new CustomField("cfListMulti", "tier2"));
141+
142+
VCertTknClient client = clientResource.client();
143+
ZoneConfiguration zoneConfiguration = clientResource.zoneConfiguration();
144+
CertificateRequest certificateRequest = clientResource.certificateRequest().customFields(customFields);
145+
146+
certificateRequest = client.generateRequest(zoneConfiguration, clientResource.certificateRequest());
147+
148+
// Submit the certificate request
149+
client.requestCertificate(certificateRequest, zoneConfiguration);
150+
151+
// Retrieve PEM collection from Venafi
152+
PEMCollection pemCollection = client.retrieveCertificate(certificateRequest);
153+
154+
155+
//At this moment certificate, must be created, it will fail if some custom fields aren't supported or specified on tpp
156+
//so is enough to validate if certificate is created.
157+
assertTrue(pemCollection.certificate() != null);
158+
159+
}
160+
161+
@Test
162+
void importCertificate() throws VCertException {
163+
final String cert = "-----BEGIN CERTIFICATE-----\n"
164+
+ "MIIDdjCCAl6gAwIBAgIRAPqSZQ04IjWgO2rwIDRcOY8wDQYJKoZIhvcNAQENBQAw\n"
165+
+ "gYAxCzAJBgNVBAYTAlVTMQ0wCwYDVQQIDARVdGFoMRcwFQYDVQQHDA5TYWx0IExh\n"
166+
+ "a2UgQ2l0eTEPMA0GA1UECgwGVmVuYWZpMRswGQYDVQQLDBJOT1QgRk9SIFBST0RV\n"
167+
+ "Q1RJT04xGzAZBgNVBAMMElZDZXJ0IFRlc3QgTW9kZSBDQTAeFw0xODA5MTIxMzUw\n"
168+
+ "MzNaFw0xODEyMTExMzUwMzNaMCQxIjAgBgNVBAMTGWltcG9ydC52ZW5hZmkuZXhh\n"
169+
+ "bXBsZS5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQChjQk0jSE5\n"
170+
+ "ktVdH8bAM0QCpGs1rOOVMmRkMc7d4hQ6bTlFlIypMq9t+1O2Z8i4fiKDS7vSBmBo\n"
171+
+ "WBgN9e0fbAnKEvBIcNLBS4lmwzRDxDCrNV3Dr5s+yJtUw9V2XBwiXbtW7qs5+c0O\n"
172+
+ "y7a2S/5HudXUlAuXf7SF4MboMMpHRg+UkyA4j0peir8PtmlJjlYBt3lZdaeLlD6F\n"
173+
+ "EIlIVQFZ6ulUF/kULhxhTUl2yNUUzJ/bqJlhFU6pkL+GoW1lnaZ8FYXwA1EKYyRk\n"
174+
+ "DYL581eqvIBJY9tCNWbOdU1r+5wR4OOKe/WWWhcDC6nL/M8ZYhfQg1nHoD58A8Dk\n"
175+
+ "H4AAt8A3EZpdAgMBAAGjRjBEMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB\n"
176+
+ "/wQCMAAwHwYDVR0jBBgwFoAUzqRFDvLX0mz4AjPb45tLGavm8AcwDQYJKoZIhvcN\n"
177+
+ "AQENBQADggEBABa4wqh+A63O5PHrdUCBSmQs9ve/oIXj561VBmqXkTHLrtKtbtcA\n"
178+
+ "yvsMi8RD8BibBAsUCljkCmLoQD/XeQFtsPlMAxisSMYhChh58008CIYDR8Nf/qoe\n"
179+
+ "YfzdMB/3VWCqTn9KGF8aMKeQvbFvuqmbtdCv//eYe6mNe2fa/x6PSdGMi4BPmjUC\n"
180+
+ "PmBT4p1iwMtu8LnL4UM4awjmmExR4X4rafcyGEbf0D/CRfhDLSwxvrrVcWd6TMMY\n"
181+
+ "HPZ/pw//+UrVLgEEsyM2zwf+LokbszPBvPAtHMJtr7Pnq2MQtEEkLfPqOWG3ol1H\n"
182+
+ "t+4v2LIW1q4GkwOUjPqgyIaJC5jj5pH9/g8=\n" + "-----END CERTIFICATE-----";
183+
184+
final String pk = "-----BEGIN RSA PRIVATE KEY-----\n"
185+
+ "MIIEpAIBAAKCAQEAoY0JNI0hOZLVXR/GwDNEAqRrNazjlTJkZDHO3eIUOm05RZSM\n"
186+
+ "qTKvbftTtmfIuH4ig0u70gZgaFgYDfXtH2wJyhLwSHDSwUuJZsM0Q8QwqzVdw6+b\n"
187+
+ "PsibVMPVdlwcIl27Vu6rOfnNDsu2tkv+R7nV1JQLl3+0heDG6DDKR0YPlJMgOI9K\n"
188+
+ "Xoq/D7ZpSY5WAbd5WXWni5Q+hRCJSFUBWerpVBf5FC4cYU1JdsjVFMyf26iZYRVO\n"
189+
+ "qZC/hqFtZZ2mfBWF8ANRCmMkZA2C+fNXqryASWPbQjVmznVNa/ucEeDjinv1lloX\n"
190+
+ "Awupy/zPGWIX0INZx6A+fAPA5B+AALfANxGaXQIDAQABAoIBAE7of6WOhbsEcHkz\n"
191+
+ "CzZYFBEiVEd8chEu8wBJn9ybD/xV21KUM3x1iGC1EPeYi98ppRvygwQcHzz4Qo+X\n"
192+
+ "HsJpWAK+62TGzvqhNbTfBglPq+IEiA8MGE07WTu3B+3vIcLbe6UDoNkJndJrSIyU\n"
193+
+ "Y9iO+dYClgLi2r9FwoIpSrQzkWqlB3edle4Nq1WABtWTOSDYysz1gk0KrLmQQfXP\n"
194+
+ "CPiwkL0SjB+sfbOiVX0B2liV2oxJ5VZWNo/250wFcvrcYrgTNtEVNMXtpN0tnRMH\n"
195+
+ "NPwnY+B9WGu/NVhtvOcOTPHq9xQhbmBCS1axikizCaIqEOyegdeDJ4ASJnVybfCA\n"
196+
+ "KzjoCpUCgYEAwOmeEvzSP8hCKtLPU8QDBA1y+mEvZMwBY4qr3hfqv3qa0QmFvxkk\n"
197+
+ "7Ubmy2oFOoUnVgnhRzAf/bajbkz4ScUgd2JrUdIEhNNVwDn/llnS/UHBlZY++BtW\n"
198+
+ "mvyon9ObXgPNPoHcJqzrqARu8PPJQEsZ+xjxM/gyif3prn6Uct6R8B8CgYEA1mHd\n"
199+
+ "Astwht39z16FoX9rQRGgx64Z0nesfTjl+4mkypz6ukkcfU1GjobqEG3k666+OJk1\n"
200+
+ "SRs8s20Pahrh21LO5x/QtvChhZ+nIedqlhBlNH9uUJI9ChbUN0luetiSPT8F5aqg\n"
201+
+ "gZMY13K5icAQ+98EcNwl7ZhVPq0BvLlbqTWi9gMCgYEAjtVqoQxob6lKtIJZ19+t\n"
202+
+ "i/aZRyFmAe+6p4UpM8vpl9SjhFrUmGV5neV9ROc+79FfCqlOD3NmfGgaIbUDsTsv\n"
203+
+ "irVoWLBzgBUpzKYkw6HGQpXJS4RvIyy6tw6Tm6MFylpuQPXNlyU5ZrHBos4eGGiC\n"
204+
+ "2BPjo2MFqH5D41r9dv+sdmkCgYEAtSJYx3y2pe04/xYhGFP9fivzyeMrRC4DWoZR\n"
205+
+ "oxcoWl0KZ41QefppzBDoAVuo2Q17AX1JjWxq/DsAlCkEffhYguXZxkhIYQuE/lt2\n"
206+
+ "LjbKG/IzdfYphrXFNrVfmIIWBZOTWvqwxOpRSfBQHbhfYUCMkwMfNMHJ/LvWxOtk\n"
207+
+ "K/L6rpsCgYB6p9RU2kXexAh9kUpbGqVeJBoIh6ArXHgepESE/7dPw26D0DM0mef0\n"
208+
+ "X1MasxN3JF7ZsSGfcCLXnICSJHuNTy9WztqF3hUbQwYd9vmZxtzAo5/fK4DVAaXS\n"
209+
+ "ZtIVl/CH/az0xqLKWIlmWOip9SfUVlZdgege+PlQtRqoFVOsH8+MEg==\n"
210+
+ "-----END RSA PRIVATE KEY-----";
211+
212+
ImportRequest importRequest = new ImportRequest();
213+
importRequest.certificateData(cert);
214+
importRequest.privateKeyData(pk);
215+
importRequest.policyDN(clientResource.zoneConfiguration().zoneId());
216+
217+
218+
ImportResponse response = clientResource.client().importCertificate(importRequest);
219+
assertThat(response).isNotNull();
220+
assertThat(response.certificateDN()).isNotNull();
221+
assertThat(response.certificateVaultId()).isGreaterThan(0);
222+
assertThat(response.privateKeyVaultId()).isGreaterThan(0);
223+
}
224+
225+
@Test
226+
void privateKeyPKCSTest() throws VCertException, UnknownHostException, IOException {
227+
VCertTknClient client = clientResource.client();
228+
ZoneConfiguration zoneConfiguration = clientResource.zoneConfiguration();
229+
230+
//By default the DataFormat of the CertificateRequest is PKCS8
231+
CertificateRequest certificateRequest = clientResource.certificateRequest()
232+
.csrOrigin(CsrOriginOption.ServiceGeneratedCSR)
233+
.keyPassword(TestUtils.KEY_PASSWORD);
234+
235+
certificateRequest = client.generateRequest(zoneConfiguration, certificateRequest);
236+
String pickupId = client.requestCertificate(certificateRequest, zoneConfiguration);
237+
assertThat(pickupId).isNotNull();
238+
239+
//Retrieving the PemCollection
240+
PEMCollection pemCollectionRSAPrivateKeyPKCS8 = client.retrieveCertificate(certificateRequest);
241+
242+
//getting the PrivateKey as PEM which should be a RSA Private Key in PKCS8 Encrypted
243+
String privateKeyPKCS8AsEncryptedPem = pemCollectionRSAPrivateKeyPKCS8.pemPrivateKey();
244+
245+
PemObject privateKeyPKCS8AsPemObject = new PemReader(new StringReader(privateKeyPKCS8AsEncryptedPem)).readPemObject();
246+
247+
//evaluating that the private Key is in PKCS8 Encrypted
248+
assertThat(pemCollectionRSAPrivateKeyPKCS8.privateKey()).isNotNull();
249+
assertTrue(privateKeyPKCS8AsPemObject.getType().equals(TestUtils.PEM_HEADER_PKCS8_ENCRYPTED));
250+
251+
//changing to data format Legacy in order to get the PrivateKey in PKCS1
252+
certificateRequest.dataFormat(DataFormat.LEGACY);
253+
254+
//Retrieving the PemCollection
255+
PEMCollection pemCollectionRSAPrivateKey = client.retrieveCertificate(certificateRequest);
256+
257+
//getting the PrivateKey as PEM which should be a RSA Private Key Encrypted
258+
String privateKeyRSAAsEncryptedPem = pemCollectionRSAPrivateKey.pemPrivateKey();
259+
260+
PemObject privateKeyRSAAsPemObject = new PemReader(new StringReader(privateKeyRSAAsEncryptedPem)).readPemObject();
261+
262+
//evaluating that the private Key is in PKCS1 Encrypted
263+
assertThat(pemCollectionRSAPrivateKey.privateKey()).isNotNull();
264+
assertTrue(privateKeyRSAAsPemObject.getHeaders().stream().anyMatch(header -> TestUtils.PEM_RSA_PRIVATE_KEY_ENCRYPTED_HEADER_VALUE.equals(((PemHeader)header).getValue())));
265+
}
266+
267+
}

0 commit comments

Comments
 (0)