def _decryptWithMyPrivateKey(self, message):
from algorithmcontroller import getAlgorithmController
rsa = getAlgorithmController().getAlgorithm("rsa")
rsa.setKeyPair(self._privateKey)
return rsa.decrypt(message)
def testSecurityController():
from algorithmcontroller import getAlgorithmController
print getAlgorithmController().getAvailableAlgorithms()
print getAlgorithmController().getOpenAlgorithms()
algRsa = getAlgorithmController().getAlgorithm("rsa")
privatekey = algRsa.createKeyPair(512)
algRsa.setKeyPair(privatekey)
pubkeystr = algRsa.getPublicKey()
message = "hello world"
cipher = algRsa.encrypt(message, pubkeystr)
print cipher
sig = algRsa.signMessage(message)
print "Signature: ", sig
plain = algRsa.decrypt(cipher)
print plain
print "Verified? ", algRsa.validate(plain, sig, pubkeystr)
def validate(self, message, signature, key, algorithm):
"""
Verifies, whether the given signature corrosponds with the given message.
@return: Indicates, whether message and signature belong togehter.
@rtype: C{Boolean}
"""
algorithm = getAlgorithmController().getAlgorithm(algorithm)
return algorithm.validate(message, signature, key)
def signMessage(self, message, algorithm):
"""
Provides a signature for the given message.
Key is not need here since the private key stored for this algorithm will be used.
@return: The signature
@rtype: C{String}
"""
algorithm = getAlgorithmController().getAlgorithm(algorithm)
signature = algorithm.signMessage(message)
return signature
def _createAuthenticationToken(self):
"""
We simply use RSA here.
"""
from algorithmcontroller import getAlgorithmController
rsa = getAlgorithmController().getAlgorithm("rsa")
rsa.setKeyPair(self._privateKey)
import random
plain = ""
for i in range(0, 100):
plain += chr(random.randint(0, 127))
signature = rsa.signMessage(plain)
return plain, signature
def encrypt(self, message, key, algorithm):
"""
Encrypts the message using the the given key and algorithm.
The corresponding algorithm is loaded using the name and the messages together with
the key is passed to the encryption method in there.
@param message: Plain text to be encrypted
@type message: C{String}
@param key: Key to be used for encryption
@type key: C{String}
@param algorithm: Name of the algorithm to be used for encryption
@type algorithm: C{String}
@return: Return value of the corresponding encrypt function within the implementation for the algorithm - cipher text
@rtype: C{String}
"""
algorithm = getAlgorithmController().getAlgorithm(algorithm)
cipher = algorithm.encrypt(message, key)
return cipher
def decrypt(self, message, algorithm):
"""
Decrypts the message using the the given key and algorithm.
The corresponding algorithm is loaded using the name and the messages together with
the key is passed to the decryption method in there.
Key is not need here since the private key stored for this algorithm will be used.
@param message: Cipher text to be decrypted
@type message: C{String}
@param algorithm: Name of the algorithm to be used for decryption
@type algorithm: C{String}
@return: Return value of the corresponding decrypt function within the implementation for the algorithm - plain text
@rtype: C{String}
"""
algorithm = getAlgorithmController().getAlgorithm(algorithm)
plain = algorithm.decrypt(message)
return plain
def installOneKey(algId, i, localMemberId):
"""
Install key for one algorithm
"""
from algorithmcontroller import getAlgorithmController
from securitymanager import getAlgorithmManager
algName = getAlgorithmManager().getAlgorithm(algId).getName()
_printAction (i, "Personal Credential for algorithm '" + algName + "'")
algImplementation = getAlgorithmController().getAlgorithm(algName)
privateKey = algImplementation.createKeyPair()
publicKey = algImplementation.getPublicKey(privateKey)
from securitymanager import PersonalCredential
credential = PersonalCredential(None, algName + " key pair", algId, privateKey, publicKey, "")
from securitymanager import getPersonalCredentialManager
getPersonalCredentialManager().addPersonalCredential(credential)
_finishActionLine()
_printAction (i, "Public Credential for algorithm '" + algName + "'")
from securitymanager import Credential
from securitymanager import getCredentialManager
credential = Credential(None, algId, "", publicKey, localMemberId)
getCredentialManager().addCredential(credential)
_finishActionLine()
def installAlgorithms(i, localMemberId):
"""
Put all algorithms into the database.
@return: list of algorithm ids.
@rtype: C{List} of C{String}
"""
_printAction (i, "Initialise algorithms", 1)
from algorithmcontroller import getAlgorithmController
from securitymanager import getAlgorithmManager
from securitymanager import Algorithm
allOpen = getAlgorithmController().getOpenAlgorithms()
returnList = []
for algName in allOpen:
_printAction (i +1, "Algorithm '" + algName)
## alg = Algorithm(None, algName)
## getAlgorithmManager().addAlgorithm(alg)
alg = getAlgorithmManager().getAlgorithmByNameAndInsert(algName)
returnList.append(alg.getId())
_finishActionLine()
_printAction (i, "Finished algorithms")
_finishActionLine()
return returnList
self.loadConfigurations() # initialise with their private keys from the personal credential manager
## _finishActionLine()
_printAction(1, "Start G4DS logging")
from g4dslogging import getDefaultLogger
try:
getDefaultLogger()
_finishActionLine()
except G4dsException, msg:
_finishActionLine(SUCESS_NEG)
_printAction(2, str(msg))
_finishActionLine(SUCESS_NEG)
_printAction(1, "Loading Keys")
from algorithmcontroller import getAlgorithmController
getAlgorithmController().loadKeys() # initialise with their private keys from the personal credential manager
_finishActionLine()
_printAction(1, "Start up protocols and listeners")
from protocolcontroller import getProtocolController
import socket
try:
getProtocolController() # start listening on all endpoints
_finishActionLine()
except socket.error, msg:
_finishActionLine(SUCESS_NEG)
_printAction(2, str(msg))
_finishActionLine(SUCESS_NEG)
_printAction(1, "Load up permission policies into memory")
from authorisationcontroller import getAuthorisationController
