Set up service user multi-factor authentication

import requests

# Configuration
BASE_URL = "https://demo.one.digicert.com"
USER_API_TOKEN = "SERVICE_USER_TOKEN"
CSR_FILE = "client_auth.csr"
CERT_NAME = "API Client Auth Certificate"
EXPIRATION_DATE = "2026-10-20T23:59:59Z"

# Read CSR from file
with open(CSR_FILE, "r") as f:
    csr_content = f.read()

# Create client authentication certificate
payload = {
    "csr": csr_content,
    "name": CERT_NAME,
    "expiration_date": EXPIRATION_DATE
}

response = requests.post(
    f"{BASE_URL}/account/api/v1/client-auth-certificate",
    headers={
        "x-api-key": SERVICE_USER_TOKEN,
        "Content-Type": "application/json"
    },
    json=payload
)

print(f"Status Code: {response.status_code}")
print(response.json())

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Paths;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;

public class Example {
    public static void main(String[] args) throws Exception {
        // Configuration
        String baseUrl = "https://demo.one.digicert.com";
        String userApiToken = "SERVICE_USER_TOKEN";
        String csrFile = "client_auth.csr";
        String certName = "API Client Auth Certificate";
        String expirationDate = "2026-10-20T23:59:59Z";
        
        // Read CSR from file
        String csrContent = Files.readString(Paths.get(csrFile));
        
        // Build JSON payload
        ObjectMapper mapper = new ObjectMapper();
        ObjectNode payload = mapper.createObjectNode();
        payload.put("csr", csrContent);
        payload.put("name", certName);
        payload.put("expiration_date", expirationDate);
        
        // Create client authentication certificate
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(baseUrl + "/account/api/v1/client-auth-certificate"))
            .header("x-api-key", userApiToken)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(mapper.writeValueAsString(payload)))
            .build();
        
        HttpResponse<String> response = client.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        System.out.println("Status Code: " + response.statusCode());
        System.out.println(response.body());
    }
}

using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json.Nodes;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        // Configuration
        string baseUrl = "https://demo.one.digicert.com";
        string userApiToken = "SERVICE_USER_TOKEN";
        string csrFile = "client_auth.csr";
        string certName = "API Client Auth Certificate";
        string expirationDate = "2026-10-20T23:59:59Z";
        
        // Read CSR from file
        string csrContent = await File.ReadAllTextAsync(csrFile);
        
        // Build JSON payload
        var payload = new JsonObject
        {
            ["csr"] = csrContent,
            ["name"] = certName,
            ["expiration_date"] = expirationDate
        };
        
        // Create client authentication certificate
        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("x-api-key", userApiToken);
        
        var content = new StringContent(
            payload.ToJsonString(), 
            Encoding.UTF8, 
            "application/json"
        );
        
        var response = await client.PostAsync(
            $"{baseUrl}/account/api/v1/client-auth-certificate",
            content
        );
        
        string responseBody = await response.Content.ReadAsStringAsync();
        Console.WriteLine($"Status Code: {(int)response.StatusCode}");
        Console.WriteLine(responseBody);
    }
}

import requests
from cryptography.hazmat.primitives.serialization import pkcs12, Encoding, PrivateFormat, NoEncryption

# Configuration
BASE_URL = "https://clientauth.demo.one.digicert.com"
CERT_FILE = "client_auth.p12"
CERT_PASSWORD = "YOUR_PASSWORD"

# Load PKCS12 certificate
with open(CERT_FILE, "rb") as f:
    p12_data = f.read()

# Extract certificate and private key
private_key, certificate, additional_certs = pkcs12.load_key_and_certificates(
    p12_data,
    CERT_PASSWORD.encode()
)

# Convert to PEM format for requests
cert_pem = certificate.public_bytes(Encoding.PEM)
key_pem = private_key.private_bytes(
    Encoding.PEM,
    PrivateFormat.TraditionalOpenSSL,
    NoEncryption()
)

# Write temporary PEM files
with open("temp_cert.pem", "wb") as f:
    f.write(cert_pem)

with open("temp_key.pem", "wb") as f:
    f.write(key_pem)

# Get user details using client certificate authentication
response = requests.get(
    f"{BASE_URL}/account/api/v1/user/me",
    cert=("temp_cert.pem", "temp_key.pem")
)

print(f"Status Code: {response.status_code}")
print(response.json())

import java.io.FileInputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.security.KeyStore;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;

public class Example {
    public static void main(String[] args) throws Exception {
        // Configuration
        String baseUrl = "https://clientauth.demo.one.digicert.com";
        String certFile = "client_auth.p12";
        String certPassword = "YOUR_PASSWORD";
        
        // Load PKCS12 certificate
        KeyStore keyStore = KeyStore.getInstance("PKCS12");
        try (FileInputStream fis = new FileInputStream(certFile)) {
            keyStore.load(fis, certPassword.toCharArray());
        }
        
        // Configure SSL context with client certificate
        KeyManagerFactory kmf = KeyManagerFactory.getInstance(
            KeyManagerFactory.getDefaultAlgorithm()
        );
        kmf.init(keyStore, certPassword.toCharArray());
        
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(kmf.getKeyManagers(), null, null);
        
        // Get user details using client certificate authentication
        HttpClient client = HttpClient.newBuilder()
            .sslContext(sslContext)
            .build();
            
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(baseUrl + "/account/api/v1/user/me"))
            .GET()
            .build();
        
        HttpResponse<String> response = client.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        System.out.println("Status Code: " + response.statusCode());
        System.out.println(response.body());
    }
}

using System;
using System.Net.Http;
using System.Security.Cryptography.X509Certificates;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        // Configuration
        string baseUrl = "https://clientauth.demo.one.digicert.com";
        string certFile = "client_auth.p12";
        string certPassword = "YOUR_PASSWORD";
        
        // Load PKCS12 certificate
        var certificate = new X509Certificate2(certFile, certPassword);
        
        // Create HttpClientHandler with client certificate
        var handler = new HttpClientHandler();
        handler.ClientCertificates.Add(certificate);
        
        // Get user details using client certificate authentication
        using var client = new HttpClient(handler);
        
        var response = await client.GetAsync(
            $"{baseUrl}/account/api/v1/user/me"
        );
        
        string responseBody = await response.Content.ReadAsStringAsync();
        Console.WriteLine($"Status Code: {(int)response.StatusCode}");
        Console.WriteLine(responseBody);
    }
}

{
    "errors": [
        {
            "code": "no_access",
            "message": "Not enough permissions"
        }
    ]
}

{
    "errors": [
        {
            "code": "invalid_input_field",
            "message": "Wrong input or input format"
        }
    ]
}