def generate_rsa_signature(http_request,
consumer_key,
rsa_key,
timestamp,
nonce,
version,
next='oob',
token=None,
token_secret=None,
verifier=None):
import base64
try:
from tlslite.utils import keyfactory
except ImportError:
from gdata.tlslite.utils import keyfactory
base_string = build_oauth_base_string(http_request,
consumer_key,
nonce,
RSA_SHA1,
timestamp,
version,
next,
token,
verifier=verifier)
private_key = keyfactory.parsePrivateKey(rsa_key)
# Sign using the key
signed = private_key.hashAndSign(base_string)
return base64.b64encode(signed)
def sign(self, request, consumer, token):
"""Builds the base signature string."""
key, raw = self.signing_base(request, consumer, token)
parsed_key = keyfactory.parsePrivateKey(self.private_key)
signature = parsed_key.hashAndSign(bytes(raw, "utf-8"))
return base64.b64encode(signature)
def generate_rsa_signature(
http_request,
consumer_key,
rsa_key,
timestamp,
nonce,
version,
next="oob",
token=None,
token_secret=None,
verifier=None,
):
import base64
try:
from tlslite.utils import keyfactory
except ImportError:
from gdata.tlslite.utils import keyfactory
base_string = build_oauth_base_string(
http_request, consumer_key, nonce, RSA_SHA1, timestamp, version, next, token, verifier=verifier
)
private_key = keyfactory.parsePrivateKey(rsa_key)
# Sign using the key
signed = private_key.hashAndSign(base_string)
# Python2.3 does not have base64.b64encode.
if hasattr(base64, "b64encode"):
return base64.b64encode(signed)
else:
return base64.encodestring(signed).replace("\n", "")
def sign(self, request, consumer, token):
"""Builds the base signature string."""
key, raw = self.signing_base(request, consumer, token)
privatekey = keyfactory.parsePrivateKey(config.JIRA_OAUTH_PEM)
signature = privatekey.hashAndSign(raw.encode('utf-8'))
return base64.b64encode(signature)
def sign(self, request, consumer, token):
"""Builds the base signature string."""
key, raw = self.signing_base(request, consumer, token)
privateKeyString = self.key_cert.strip()
privatekey = keyfactory.parsePrivateKey(privateKeyString)
signature = privatekey.hashAndSign(raw)
return base64.b64encode(signature)
def sign(self, oauth_request, consumer, token):
"""Builds the base signature string."""
base_string = self.build_signature_base_string(oauth_request, consumer, token)
# Fetch the private key cert based on the request
cert = self._fetch_private_cert(oauth_request)
# Pull the private key from the certificate
privatekey = keyfactory.parsePrivateKey(cert)
# Sign using the key
signed = privatekey.hashAndSign(base_string)
return binascii.b2a_base64(signed)[:-1]
def generate_signature(data, rsa_key):
"""Signs the data string for a secure AuthSub request."""
import base64
try:
from tlslite.utils import keyfactory
except ImportError:
from gdata.tlslite.utils import keyfactory
private_key = keyfactory.parsePrivateKey(rsa_key)
signed = private_key.hashAndSign(data)
return base64.b64encode(signed)
def generate_signature(data, rsa_key):
"""Signs the data string for a secure AuthSub request."""
import base64
try:
from tlslite.utils import keyfactory
except ImportError:
from gdata.tlslite.utils import keyfactory
private_key = keyfactory.parsePrivateKey(rsa_key)
signed = private_key.hashAndSign(data)
return base64.b64encode(signed)
def sign(self, request, consumer, token):
"""Builds the base signature string."""
key, raw = self.signing_base(request, consumer, token)
privateKeyString = self.key_cert.strip()
privatekey = keyfactory.parsePrivateKey(privateKeyString)
signature = privatekey.hashAndSign(raw)
return base64.b64encode(signature)
def sign(self, request, consumer, token):
key, raw = self.signing_base(request, consumer, token)
with open('./privkey.pem', 'r') as f:
data = f.read()
privateKeyString = data.strip()
privatekey = keyfactory.parsePrivateKey(privateKeyString)
signature = privatekey.hashAndSign(raw)
return base64.b64encode(signature)
def sign(self, request: oauth2.Request, consumer: oauth2.Consumer,
token: oauth2.Token) -> bytes:
"""Builds the base signature string."""
key, raw = self.signing_base(request=request,
consumer=consumer,
token=token)
private_key = keyfactory.parsePrivateKey(self.rsa_private_key)
# noinspection PyArgumentList
signature = private_key.hashAndSign(bytes=bytearray(raw, 'utf8'))
return base64.b64encode(signature)
def _pure_python_rsa_sha1(base_string, rsa_private_key):
"""
An alternative, pure-python RSA-SHA1 signing method, using
the tlslite library.
"""
import base64
from tlslite.utils import keyfactory
private_key = keyfactory.parsePrivateKey(rsa_private_key)
signature = private_key.hashAndSign(base_string.encode('ascii'))
return unicode(base64.b64encode(signature))
def sign(self, request, consumer, token):
"""Builds the base signature string."""
key, raw = self.signing_base(request, consumer, token)
with open(os.getenv('PRIVATE_PEM_KEY', 'pem_key_not_set'), 'r') as f:
data = f.read()
privateKeyString = data.strip()
privatekey = keyfactory.parsePrivateKey(privateKeyString)
signature = privatekey.hashAndSign(raw)
return base64.b64encode(signature)
def sign(self, request, consumer, token):
'''Builds the base signature string.'''
key, raw = self.signing_base(request, consumer, token)
with open(join(home, 'jira.pem'), 'r') as f:
data = f.read()
privateKeyString = data.strip()
privatekey = keyfactory.parsePrivateKey(privateKeyString)
signature = privatekey.hashAndSign(raw)
return base64.b64encode(signature)
def _pure_python_rsa_sha1(base_string, rsa_private_key):
"""
An alternative, pure-python RSA-SHA1 signing method, using
the tlslite library.
"""
import base64
from tlslite.utils import keyfactory
private_key = keyfactory.parsePrivateKey(rsa_private_key)
signature = private_key.hashAndSign(base_string.encode('ascii'))
return unicode(base64.b64encode(signature))
def sign(self, request, consumer, token):
"""Builds the base signature string."""
key, raw = self.signing_base(request, consumer, token)
module_dir = os.path.dirname(__file__) # get current directory
with open(module_dir + '/rsa.pem', 'r') as f:
data = f.read()
privateKeyString = data.strip()
privatekey = keyfactory.parsePrivateKey(privateKeyString)
raw = str.encode(raw)
signature = privatekey.hashAndSign(raw)
return base64.b64encode(signature)
def sign(self, request, consumer, token):
"""Builds the base signature string."""
key, raw = self.signing_base(request, consumer, token)
with open('/Users/mmuunn/Documents/Works/jira/jira-python-restful/oauth_key/mykey.pem', 'r') as f:
data = f.read()
privateKeyString = data.strip()
privatekey = keyfactory.parsePrivateKey(privateKeyString)
signature = privatekey.hashAndSign(raw)
return base64.b64encode(signature)
def sign(self, request, consumer, token):
"""Builds the base signature string."""
key, raw = self.signing_base(request, consumer, token)
with open('oauth_key/mykey.pem', 'r') as f:
data = f.read()
privateKeyString = data.strip()
privatekey = keyfactory.parsePrivateKey(privateKeyString)
signature = privatekey.hashAndSign(bytes(raw, 'utf-8'))
return base64.b64encode(signature)
def sign(self, request, consumer, token):
"""Builds the base signature string."""
key, raw = self.signing_base(request, consumer, token)
with open('../rsa.pem', 'r') as f:
data = f.read()
privateKeyString = data.strip()
privatekey = keyfactory.parsePrivateKey(privateKeyString)
signature = privatekey.hashAndSign(raw)
return base64.b64encode(signature)
def generate_signature(data, rsa_key):
"""Signs the data string for a secure AuthSub request."""
import base64
try:
from tlslite.utils import keyfactory
except ImportError:
from gdata.tlslite.utils import keyfactory
private_key = keyfactory.parsePrivateKey(rsa_key)
signed = private_key.hashAndSign(data)
# Python2.3 and lower does not have the base64.b64encode function.
if hasattr(base64, 'b64encode'):
return base64.b64encode(signed)
else:
return base64.encodebytes(signed).replace('\n', '')
def sign(self, request, consumer, token):
"""Builds the base signature string."""
key, raw = self.signing_base(request, consumer, token)
# Load RSA Private Key
with open( 'jira.pem', 'r') as f:
data = f.read()
privateKeyString = data.strip()
privatekey = keyfactory.parsePrivateKey(privateKeyString)
signature = privatekey.hashAndSign(raw)
return base64.b64encode(signature)
def generate_signature(data, rsa_key):
"""Signs the data string for a secure AuthSub request."""
import base64
try:
from tlslite.utils import keyfactory
except ImportError:
from gdata.tlslite.utils import keyfactory
private_key = keyfactory.parsePrivateKey(rsa_key)
signed = private_key.hashAndSign(data)
# Python2.3 and lower does not have the base64.b64encode function.
if hasattr(base64, 'b64encode'):
return base64.b64encode(signed)
else:
return base64.encodestring(signed).replace('\n', '')
def generate_rsa_signature(http_request, consumer_key, rsa_key,
timestamp, nonce, version, next='oob',
token=None, token_secret=None, verifier=None):
import base64
try:
from tlslite.utils import keyfactory
except ImportError:
from gdata.tlslite.utils import keyfactory
base_string = build_oauth_base_string(
http_request, consumer_key, nonce, RSA_SHA1, timestamp, version,
next, token, verifier=verifier)
private_key = keyfactory.parsePrivateKey(rsa_key)
# Sign using the key
signed = private_key.hashAndSign(base_string)
return base64.b64encode(signed)
def sign(self, request, consumer, token):
"""Builds the base signature string."""
key, raw = self.signing_base(request, consumer, token)
with open(
(Path(__file__).parent / self.private_key_filename).resolve(),
'r') as f:
data = f.read()
private_key_string = data.strip()
private_key = keyfactory.parsePrivateKey(private_key_string)
signature = private_key.hashAndSign(bytes(raw, encoding='utf8'))
return base64.b64encode(signature)
def sign(self, request, consumer, token):
"""Builds the base signature string."""
key, raw = self.signing_base(request, consumer, token)
env = Environment.Environment()
absolute_path = env.get_path_private_key()
with open(absolute_path, 'r') as f:
data = f.read()
private_key_string = data.strip()
private_key = keyfactory.parsePrivateKey(private_key_string)
signature = private_key.hashAndSign(raw)
base_signature = base64.b64encode(signature)
return base_signature
def sign(self, request, consumer, token):
"""
Build signature string.
:param request: http request
:param consumer: oauth consumer
:param token: oauth token
:return: signed signature b64
"""
key, raw = self.signing_base(request, consumer, token)
private_key = read_key_cert()
privatekey = keyfactory.parsePrivateKey(private_key)
signature = privatekey.hashAndSign(raw)
return base64.b64encode(signature)
def oauth_sign(method, url, params, data, private_key_path):
"""Returns oauth_signature for a given request"""
# Use oauth2 Request() to normalize the payload
request = oauth2.Request(method, url, params, data)
raw = '&'.join([
oauth2.escape(request.method),
oauth2.escape(request.normalized_url),
oauth2.escape(request.get_normalized_parameters()),
])
# Load the private keyfile
with open(private_key_path, 'r') as f:
privatekey = keyfactory.parsePrivateKey(f.read())
# Calculate signature and return it as a b64-encoded string
return base64.b64encode(privatekey.hashAndSign(raw))
def build_signature(self, oauth_request, consumer, token):
key, base_string = self.build_signature_base_string(
oauth_request, consumer, token)
# Fetch the private key cert based on the request
cert = self._fetch_private_cert(oauth_request)
# Pull the private key from the certificate
privatekey = keyfactory.parsePrivateKey(cert)
# Convert base_string to bytes
# base_string_bytes = cryptomath.createByteArraySequence(base_string)
# Sign using the key
signed = privatekey.hashAndSign(base_string)
return binascii.b2a_base64(signed)[:-1]
def build_signature(self, oauth_request, consumer, token):
key, base_string = self.build_signature_base_string(oauth_request,
consumer,
token)
# Fetch the private key cert based on the request
cert = self._fetch_private_cert(oauth_request)
# Pull the private key from the certificate
privatekey = keyfactory.parsePrivateKey(cert)
# Convert base_string to bytes
#base_string_bytes = cryptomath.createByteArraySequence(base_string)
# Sign using the key
signed = privatekey.hashAndSign(base_string)
return base64.b64encode(signed)
def sign(self, request, consumer, token):
"""Builds the base signature string."""
key, raw = self.signing_base(request, consumer, token)
# Load RSA Private Key
with open(Path.home() / '.oauthconfig/oauth.pem', 'r') as f:
data = f.read()
privateKeyString = data.strip()
privatekey = keyfactory.parsePrivateKey(privateKeyString)
'''
We were getting errors on encoding, so added explicitly "utf8" encoding in rsakey.py
In function hashAndSign(...),
*changed line* -> hashBytes = SHA1(bytearray(bytes))
to -> hashBytes = SHA1(bytearray(bytes, "utf8"))
'''
signature = privatekey.hashAndSign(raw)
return base64.b64encode(signature)
def verify(self, base_string, signature):
decoded_sig = base64.b64decode(signature)
public_key = keyfactory.parsePrivateKey(self.public_cert)
return publickey.hashAndVerify(decoded_sig, base_string)
# Signing a string with RSA private key on Google App Engine Python SDK from tlslite.utils import keyfactory private_key = keyfactory.parsePrivateKey(rsa_key) signed = private_key.hashAndSign(data)
# Signing a string with RSA private key on Google App Engine Python SDK from tlslite.utils import keyfactory private_key = keyfactory.parsePrivateKey(rsa_key) signed = private_key.hashAndSign(data)
def signature(self):
privatekey = keyfactory.parsePrivateKey(self.private_cert)
signature = privatekey.hashAndSign(self.base_string)
return base64.b64encode(signature)
