PowerBuilder

Duplicate openssl req -newkey rsa:2048 -nodes -keyout mydomain.pem -out mydomain.csr

See more OpenSSL Examples

Demonstrates how to duplicate this OpenSSL command:

openssl req -newkey rsa:2048 -nodes -keyout mydomain.pem -out mydomain.csr

This command creates 2 files:

1. mydomain.csr: this is the file to send to DigiCert or Let's Encrypt (or any other CA)
2. mydomain.pem: this is the private key of the domain.

The second file is needed to pair with the certificate that will later be received from the CA.

PowerBuilder

integer li_rc
integer li_Success
oleobject loo_Rsa
oleobject loo_PrivKey
oleobject loo_PrivKeyXml
string ls_KeyModulus
oleobject loo_AsnRoot
oleobject loo_AsnCertReqInfo
oleobject loo_AsnCertSubject
oleobject loo_AsnTemp
oleobject loo_AsnPubKeyInfo
oleobject loo_AsnPubKeyAlgId
oleobject loo_AsnRsaKey
string ls_RsaKeyDerBase64
oleobject loo_BdDer
oleobject loo_BdSig
oleobject loo_AsnAlgId
string ls_CsrBase64

li_Success = 0

// This example requires the Chilkat API to have been previously unlocked.
// See Global Unlock Sample for sample code.

loo_Rsa = create oleobject
li_rc = loo_Rsa.ConnectToNewObject("Chilkat.Rsa")
if li_rc < 0 then
    destroy loo_Rsa
    MessageBox("Error","Connecting to COM object failed")
    return
end if

// Generate a 2048-bit key.  Chilkat RSA supports
// key sizes ranging from 512 bits to 8192 bits.
loo_PrivKey = create oleobject
li_rc = loo_PrivKey.ConnectToNewObject("Chilkat.PrivateKey")

li_Success = loo_Rsa.GenKey(2048,loo_PrivKey)
if li_Success = 0 then
    Write-Debug loo_Rsa.LastErrorText
    destroy loo_Rsa
    destroy loo_PrivKey
    return
end if

loo_Rsa.UsePrivateKey(loo_PrivKey)

// Save the private key to unencrypted PKCS8 PEM
li_Success = loo_PrivKey.SavePkcs8PemFile("mydomain.pem")

// (alternatively) Save the private key to encrypted PKCS8 PEM
li_Success = loo_PrivKey.SavePkcs8EncryptedPemFile("myPassword","mydomain_enc.pem")

// We'll need the private key's modulus for the CSR.
// The modulus is not something that needs to be protected.  Most people don't realize
// that a public key is actually just a subset of the private key.  The public parts of
// an RSA private key are the modulus and exponent.  The exponent is always 65537.
loo_PrivKeyXml = create oleobject
li_rc = loo_PrivKeyXml.ConnectToNewObject("Chilkat.Xml")

li_Success = loo_PrivKeyXml.LoadXml(loo_PrivKey.GetXml())

// Get the modulus in base64 format:
ls_KeyModulus = loo_PrivKeyXml.GetChildContent("Modulus")

// --------------------------------------------------------------------------------
// Now build the CSR using Chilkat's ASN.1 API.
// The keyModulus will be embedded within the ASN.1.

// A new ASN.1 object is automatically a SEQUENCE.
// Given that the CSR's root item is a SEQUENCE, we can use
// this as the root of our CSR.
loo_AsnRoot = create oleobject
li_rc = loo_AsnRoot.ConnectToNewObject("Chilkat.Asn")

// Beneath the root, we have a SEQUENCE (the certificate request info), 
// another SEQUENCE (the algorithm identifier), and a BITSTRING (the signature data)

li_Success = loo_AsnRoot.AppendSequence()
li_Success = loo_AsnRoot.AppendSequence()

// ----------------------------------
// Build the Certificate Request Info
// ----------------------------------
loo_AsnCertReqInfo = loo_AsnRoot.GetSubItem(0)
li_Success = loo_AsnCertReqInfo.AppendInt(0)

// Build the Subject part of the Certificate Request Info
loo_AsnCertSubject = loo_AsnCertReqInfo.AppendSequenceR()

// Add each subject part..
loo_AsnTemp = loo_AsnCertSubject.AppendSetR()
li_Success = loo_AsnTemp.AppendSequence2()
// AppendSequence2 updates the internal reference to the newly appended SEQUENCE.
// The OID and printable string are added to the SEQUENCE.
li_Success = loo_AsnTemp.AppendOid("2.5.4.6")
li_Success = loo_AsnTemp.AppendString("printable","US")
destroy loo_AsnTemp

loo_AsnTemp = loo_AsnCertSubject.AppendSetR()
li_Success = loo_AsnTemp.AppendSequence2()
li_Success = loo_AsnTemp.AppendOid("2.5.4.8")
li_Success = loo_AsnTemp.AppendString("utf8","Utah")
destroy loo_AsnTemp

loo_AsnTemp = loo_AsnCertSubject.AppendSetR()
li_Success = loo_AsnTemp.AppendSequence2()
li_Success = loo_AsnTemp.AppendOid("2.5.4.7")
li_Success = loo_AsnTemp.AppendString("utf8","Lindon")
destroy loo_AsnTemp

loo_AsnTemp = loo_AsnCertSubject.AppendSetR()
li_Success = loo_AsnTemp.AppendSequence2()
li_Success = loo_AsnTemp.AppendOid("2.5.4.10")
li_Success = loo_AsnTemp.AppendString("utf8","DigiCert Inc.")
destroy loo_AsnTemp

loo_AsnTemp = loo_AsnCertSubject.AppendSetR()
li_Success = loo_AsnTemp.AppendSequence2()
li_Success = loo_AsnTemp.AppendOid("2.5.4.11")
li_Success = loo_AsnTemp.AppendString("utf8","DigiCert")
destroy loo_AsnTemp

loo_AsnTemp = loo_AsnCertSubject.AppendSetR()
li_Success = loo_AsnTemp.AppendSequence2()
li_Success = loo_AsnTemp.AppendOid("2.5.4.3")
li_Success = loo_AsnTemp.AppendString("utf8","example.digicert.com")
destroy loo_AsnTemp

destroy loo_AsnCertSubject

// Build the Public Key Info part of the Certificate Request Info
loo_AsnPubKeyInfo = loo_AsnCertReqInfo.AppendSequenceR()

loo_AsnPubKeyAlgId = loo_AsnPubKeyInfo.AppendSequenceR()
li_Success = loo_AsnPubKeyAlgId.AppendOid("1.2.840.113549.1.1.1")
li_Success = loo_AsnPubKeyAlgId.AppendNull()
destroy loo_AsnPubKeyAlgId

// The public key itself is a BIT STRING, but the bit string is composed of ASN.1
// for the RSA public key.  We'll first build the RSA ASN.1 for the public key
// (containing the 2048 bit modulus and exponent), and encoded it to DER, and then add
// the DER bytes as a BIT STRING (as a sub-item of asnPubKeyInfo)

// This is already a SEQUENCE..
loo_AsnRsaKey = create oleobject
li_rc = loo_AsnRsaKey.ConnectToNewObject("Chilkat.Asn")

// The RSA modulus is a big integer.
li_Success = loo_AsnRsaKey.AppendBigInt(ls_KeyModulus,"base64")
li_Success = loo_AsnRsaKey.AppendInt(65537)

ls_RsaKeyDerBase64 = loo_AsnRsaKey.GetEncodedDer("base64")

// Now add the RSA key DER as a BIT STRING.
li_Success = loo_AsnPubKeyInfo.AppendBits(ls_RsaKeyDerBase64,"base64")
destroy loo_AsnPubKeyInfo

// The last part of the certificate request info is an empty context-specific constructed item
// with a tag equal to 0.
li_Success = loo_AsnCertReqInfo.AppendContextConstructed(0)

// Get the DER of the asnCertReqInfo.  
// This will be signed using the RSA private key.
loo_BdDer = create oleobject
li_rc = loo_BdDer.ConnectToNewObject("Chilkat.BinData")

li_Success = loo_AsnCertReqInfo.WriteBd(loo_BdDer)

// Add the signature to the ASN.1
loo_BdSig = create oleobject
li_rc = loo_BdSig.ConnectToNewObject("Chilkat.BinData")

li_Success = loo_Rsa.SignBd(loo_BdDer,"SHA1",loo_BdSig)
li_Success = loo_AsnRoot.AppendBits(loo_BdSig.GetEncoded("base64"),"base64")

destroy loo_AsnCertReqInfo

// ----------------------------------
// Finally, add the algorithm identifier, which is the 2nd sub-item under the root.
// ----------------------------------
loo_AsnAlgId = loo_AsnRoot.GetSubItem(1)
li_Success = loo_AsnAlgId.AppendOid("1.2.840.113549.1.1.5")
li_Success = loo_AsnAlgId.AppendNull()
destroy loo_AsnAlgId

// Write the CSR to a DER encoded binary file:
li_Success = loo_AsnRoot.WriteBinaryDer("qa_output/mydomain.csr")
if li_Success = 0 then
    Write-Debug loo_AsnRoot.LastErrorText
    destroy loo_Rsa
    destroy loo_PrivKey
    destroy loo_PrivKeyXml
    destroy loo_AsnRoot
    destroy loo_AsnRsaKey
    destroy loo_BdDer
    destroy loo_BdSig
    return
end if

// It is also possible to get the CSR in base64 format:
ls_CsrBase64 = loo_AsnRoot.GetEncodedDer("base64")

Write-Debug "Base64 CSR:"
Write-Debug ls_CsrBase64


destroy loo_Rsa
destroy loo_PrivKey
destroy loo_PrivKeyXml
destroy loo_AsnRoot
destroy loo_AsnRsaKey
destroy loo_BdDer
destroy loo_BdSig