Openssl Generate Public Key From Modulus And Exponent

Posted on  by

Feb 13, 2014  node-rsa-pem-from-mod-exp. Create RSA Public Key PEM from Modulus and Exponent value in node.js. There are no dependencies to other modules for use. This allows you to use the modulus/exponent values for validating signed value. The original code is based on the answer to this stackoverflow question. Install npm install rsa-pem-from-mod-exp Usage. Jun 01, 2012  Takes a RSA public key modulus and exponent in base64 encoding and produces a public key file in PEM format - Makefile.

toRSAPublicKey.c

Openssl Generate Public Key From Modulus And Exponential

  • The -noout option allows to avoid the display of the key in base 64 format. Numbers in hexadecimal format can be seen (except the public exponent by default is always 65537 for 1024 bit keys): the modulus, the public exponent, the private, the two primes that compose the modules and three other numbers that are use to optimize the algorithm.
  • Openssl x509 -in stackexchangecom.crt -text -noout Create own cert from Private key. Use own private key to generate a self-signed certificate with it. This command creates a self-signed certificate (domain.crt) from an existing private key (domain.key): openssl req -key priv1024.pem -new -x509 -days 365 -out domain.crt Extract Public Key from.
  • Since the actual signed certificate is to associate a trust relationship between my public key and my credentials, a certificate cannot be signed without access to the public key or at least a hash of the public key. Here's the confusion for me: I see that there is a command I can execute in OpenSSL: openssl req -out CSR.csr -key privateKey.key.
  • Openssl genrsa -des3 -out private.pem 1024 (Encrypts with a password-just remove '-des3' if you'd rather not have a password on the private key) openssl rsa in private.key -pubout -out public.pem (Generate public key) Abstract the common Modulus from the public key.
#include<string.h>
#include<openssl/rsa.h>
#include<openssl/evp.h>
#include<openssl/bn.h>
#include<openssl/pem.h>
// cheating, . ignoring deprecation warnings
#pragma GCC diagnostic ignored '-Wdeprecated-declarations'
unsignedchar *base64_decode(constchar* base64data, int* len) {
BIO *b64, *bmem;
size_t length = strlen(base64data);
unsignedchar *buffer = (unsignedchar *)malloc(length);
b64 = BIO_new(BIO_f_base64());
BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
bmem = BIO_new_mem_buf((void*)base64data, length);
bmem = BIO_push(b64, bmem);
*len = BIO_read(bmem, buffer, length);
BIO_free_all(bmem);
return buffer;
}
BIGNUM* bignum_base64_decode(constchar* base64bignum) {
BIGNUM* bn = NULL;
int len;
unsignedchar* data = base64_decode(base64bignum, &len);
if (len) {
bn = BN_bin2bn(data, len, NULL);
}
free(data);
return bn;
}
EVP_PKEY* RSA_fromBase64(constchar* modulus_b64, constchar* exp_b64) {
BIGNUM *n = bignum_base64_decode(modulus_b64);
BIGNUM *e = bignum_base64_decode(exp_b64);
if (!n) printf('Invalid encoding for modulusn');
if (!e) printf('Invalid encoding for public exponentn');
if (e && n) {
EVP_PKEY* pRsaKey = EVP_PKEY_new();
RSA* rsa = RSA_new();
rsa->e = e;
rsa->n = n;
EVP_PKEY_assign_RSA(pRsaKey, rsa);
return pRsaKey;
} else {
if (n) BN_free(n);
if (e) BN_free(e);
returnNULL;
}
}
voidassert_syntax(int argc, char** argv) {
if (argc != 4) {
fprintf(stderr, 'Description: %s takes a RSA public key modulus and exponent in base64 encoding and produces a public key file in PEM format.n', argv[0]);
fprintf(stderr, 'syntax: %s <modulus_base64> <exp_base64> <output_file>n', argv[0]);
exit(1);
}
}
intmain(int argc, char** argv) {
assert_syntax(argc, argv);
constchar* modulus = argv[1];
constchar* exp = argv[2];
constchar* filename = argv[3];
EVP_PKEY* pkey = RSA_fromBase64(modulus, exp);
if (pkey NULL) {
fprintf(stderr, 'an error occurred :(n');
return2;
} else {
printf('success decoded into RSA public keyn');
FILE* file = fopen(filename, 'w');
PEM_write_PUBKEY(file, pkey);
fflush(file);
fclose(file);
printf('written to file: %sn', filename);
}
return0;
}
Sign up for freeto join this conversation on GitHub. Already have an account? Sign in to comment

Applicable Products

  • NetScaler Gateway
  • NetScaler

Objective

This article describes how to generate SHA2 Certificate Signing Request (CSR) on NetScaler using OpenSSL.

Background

Openssl Generate Public Key From Modulus And Exponents

Currently there is no option to create SHA2 CSR from NetScaler GUI however you can leverage the OpenSSL commands for creating SHA2 CSR from NetScaler.

Instructions

Complete the following steps to generate SHA2 CSR on NetScaler using OpenSSL:

Generate Rsa Public Key From Modulus And Exponent

  1. Create a custom configuration file named openssl.cnf. The file can have the following entries. Modify the entries according to the requirement. You can create this file on NetScaler using the VI editor or any other editor.

  2. Upload the openssl.cnf file to the /nsconfig/ssl directory.

  3. Log on to NetScaler using PuTTY.

  4. Browse to the /nsconfig/ssl directory and execute the following command to create a Key and CSR:
    root@ns# openssl req -out test.csr -config openssl.cnf -new -newkey rsa:2048 -nodes -keyout test.key

  5. Use the following command to verify if the CSR created is SHA2:
    root@ns# openssl req -text -noout -in test.csr grep 'Signature Algorithm'

The preceding article helps you in generating the CSR by creating a new key. However, if you want to use an existing key, then use the following command:
openssl req -out csr.csr -key /nsconfig/ssl/existing_key.key -new -sha256 -config /etc/nsssl.conf

Additional Resources

Openssl Generate Public Key From Modulus And Exponent Calculator

Alternatively you can run the following command from the shell to generate SHA2 CSR:
#openssl req -config /etc/nsssl.conf -newkey rsa:2048 -sha256 -nodes -out test.csr -outform PEM

The 'nsssl.conf' file is a NetScaler OpenSSL configuration file.

Generating new download key dropbox. Monthly subscriptions with up to 10 Atlassian product users are billed at a flat rate price. For example, if you have Confluence Cloud (25 users), you pay the 25-user price for apps.The pricing structure for cloud apps is as follows:.

Generate Public Key From Modulus And Exponent

Run the following command to confirm the SHA algorithm used:
#openssl req -text -noout -verify -in test.csr