def oracle_cbc_ecb(plaintext):
# Generate random key
key = urandom(16)
# Alternative way
# key = long_to_bytes(randbits(128)) --> Error sometimes it generates less bytes
# Probably long_to_bytes didn't work properly
# Instance secret_generator
secrets_generator = SystemRandom()
# Prepend and append chunk of 5 --> 10 bytes
chunk = secrets_generator.randint(5, 10)
plaintext = urandom(chunk) + plaintext
chunk = secrets_generator.randint(5, 10)
plaintext += urandom(chunk)
# Choose to encrypt using CBC or ECB
option = secrets_generator.randint(0, 1)
if option == 0:
cbc = CBC(key, blocksize)
iv = urandom(16)
return cbc.encrypt(iv, plaintext)
else:
pad = PKCS7(blocksize)
ecb = AES.new(key, AES.MODE_ECB)
return ecb.encrypt(pad.encode(plaintext))
def split(secret: str, recombination_threshold: int,
num_shares: int) -> (Share, ...):
"""split secret into shares using Shamir's Secret Sharing Algorithm"""
# https://en.wikipedia.org/wiki/Shamir%27s_Secret_Sharing
assert num_shares >= recombination_threshold > 1, 'Hmmm... invalid n of m specification'
assert secret, 'Hmmm... need a secret to split'
secret = secret.encode()
secret_identifier = str(uuid4())
f_0 = int.from_bytes(secret, byteorder='big', signed=False)
mersenne, modulus = _find_suitable_mersenne_prime(f_0)
rand = SystemRandom()
coefficients = (f_0, ) + tuple(
rand.randint(1, modulus - 1)
for _ in range(recombination_threshold - 1))
# value of polynomial defined by coefficients at x in modulo modulus
def f_x(x: int) -> int:
return sum((a * ((x**i) % modulus) % modulus)
for i, a in enumerate(coefficients)) % modulus
x_values = set()
while len(x_values) < num_shares:
x_values.add(rand.randint(1, 10**6))
return tuple(
Share(id=secret_identifier, mersenne=mersenne, x=x, y=f_x(x))
for x in x_values)
def test__modulo_inverse(self):
from secrets import SystemRandom
rand = SystemRandom()
for i in (32, 64, 128, 256):
x = rand.randint(0, 2**i)
_, p = cloak.secret_sharing._find_suitable_mersenne_prime(x)
y = cloak.secret_sharing._modulo_inverse(x=x, modulus=p)
self.assertEqual(1, (x * y) % p)
def system_random_without_seed():
system_random = SystemRandom()
result = [system_random.randint(1, 10) for i in range(1000)]
counter = Counter(result)
for key, value in sorted(counter.items()):
print(key, ': ', value)
def generate_token(length=30, chars=UNICODE_ASCII_CHARACTER_SET):
"""Generates a non-guessable OAuth token
OAuth (1 and 2) does not specify the format of tokens except that they
should be strings of random characters. Tokens should not be guessable
and entropy when generating the random characters is important. Which is
why SystemRandom is used instead of the default random.choice method.
"""
rand = SystemRandom()
return ''.join(rand.choice(chars) for x in range(length))
def randInt(n):
cryptogen = SystemRandom()
k = log2(n)
if(k <= 0):
k=1
k = ceil(k)
r = n
while(r >= n or r<=0):
r = cryptogen.getrandbits(k)
return r
def generate_token(length=30, chars=UNICODE_ASCII_CHARACTER_SET):
"""Generates a non-guessable OAuth token
OAuth (1 and 2) does not specify the format of tokens except that they
should be strings of random characters. Tokens should not be guessable
and entropy when generating the random characters is important. Which is
why SystemRandom is used instead of the default random.choice method.
"""
rand = SystemRandom()
return ''.join(rand.choice(chars) for x in range(length))
def test__find_suitable_mersenne_prime(self):
from secrets import SystemRandom
rand = SystemRandom()
for i in (32, 64, 128, 256):
x = rand.randint(0, 2**i)
m, p = cloak.secret_sharing._find_suitable_mersenne_prime(x)
self.assertIsInstance(m, int)
self.assertIsInstance(p, int)
self.assertGreater(p, x)
for m_ in (i for i in cloak.known_mersenne_primes if 100 < i < m):
self.assertLess(cloak.mersenne_prime(m_), x)
self.assertIn(m, cloak.known_mersenne_primes)
def randPrime(k):
p = 0
if(k==2):
while(p <= 1):
p = SystemRandom().getrandbits(1)
mask = 1 << 1
p |= mask
return p
while(not isPrime(p, PrimAcc)):
p = SystemRandom().getrandbits(k-2)
p |= 1
mask = 1 << (k-1)
p |= mask
return p
def test_mersenne_prime(self):
from math import log2
from secrets import SystemRandom
rand = SystemRandom()
for x in tuple(
rand.randint(1, 10 ^ 9)
for _ in range(100)) + cloak.known_mersenne_primes[0:10]:
if x in cloak.known_mersenne_primes:
m = cloak.mersenne_prime(x)
self.assertIsInstance(m, int)
self.assertEqual(x, int(log2(m + 1)))
else:
with self.assertRaises(AssertionError):
cloak.mersenne_prime(x)
def __init__(self, vol: float = 1, maxlength: int = 100):
"""Create a Probalist object.
@param vol: system volume for constant conversion
@type vol: float
@param maxlength: maximum probalistic events to be stored
(when run out of space, size is increased by maxlength increments)
@type maxlength: int
"""
# FIX check if vol can be removed and placed somewhere else !
self.vol: float = vol
"""system volume"""
# Check replacement with list instead of numpy array !
self._mapobj: np.ndarray = np.zeros(maxlength, dtype=np.dtype("O"))
"""List of probalistic objects"""
self._problist: np.ndarray = np.zeros(maxlength, dtype=np.float64)
"""List of probas"""
self._actlist: int = 0
"""Next available position"""
self._maxlength: int = maxlength
"""maximum probalistic event increment to be stored"""
self.probtot: float = 0.0
"""total probability"""
self._queue: Deque[int] = deque()
"""Queue of freed positions"""
self.sysrand: SystemRandom = SystemRandom()
"""random number generator (uses system generator for optimal entropy)"""
def generate_token(request, length=30, chars=UNICODE_ASCII_CHARACTER_SET):
"""Generates a non-guessable OAuth Json Web Token
OAuth (1 and 2) does not specify the format of tokens except that they
should be strings of random characters. Tokens should not be guessable
and entropy when generating the random characters is important. Which is
why SystemRandom is used instead of the default random.choice method.
"""
from django.conf import settings
from jose import jwt
rand = SystemRandom()
secret = getattr(settings, 'SECRET_KEY')
token = ''.join(rand.choice(chars) for x in range(length))
jwtted_token = jwt.encode({'token': token}, secret, algorithm='HS256')
return jwtted_token
def sample_poly_ternary(parms):
"""Generate a ternary polynomial uniformally with elements [-1, 0, 1]
where -1 is represented as (modulus - 1) because -1 % modulus == modulus - 1.
Used for generating secret key using coeff_modulus(list of prime nos) which
represents as 'q' in the research paper.
Args:
parms (EncryptionParam): Encryption parameters.
Returns:
A 2-dim list having integer from [-1, 0, 1].
"""
coeff_modulus = parms.coeff_modulus
coeff_count = parms.poly_modulus
coeff_mod_size = len(coeff_modulus)
result = [0] * coeff_mod_size
for i in range(coeff_mod_size):
result[i] = [0] * coeff_count
for i in range(coeff_count):
rand_index = SystemRandom().choice([-1, 0, 1])
if rand_index == 1:
for j in range(coeff_mod_size):
result[j][i] = 1
elif rand_index == -1:
for j in range(coeff_mod_size):
result[j][i] = coeff_modulus[j] - 1
else:
for j in range(coeff_mod_size):
result[j][i] = 0
return result
async def fetch_vacancy_page(link: str, session: ClientSession):
# Put the link, title and content in a dict – so far without skills.
for _ in range(5):
try:
async with session.get(link) as resp:
html = await resp.text()
soup = BeautifulSoup(html, "html.parser")
title = soup.find(attrs={"data-qa": "vacancy-title"}).text
content = soup.find(attrs={"data-qa": "vacancy-description"}).text
vacancy_page = {"url": link, "title": title, "content": content}
timeout = SystemRandom().uniform(1.0, 5.0)
await asyncio.sleep(timeout)
return vacancy_page
except AttributeError:
logger.warning(f"🚨 AttributeError occurred while fetching: {link}")
return None
except ClientPayloadError:
logger.warning(f"🚨 ClientPayloadError occurred while fetching: {link}")
return None
except ServerDisconnectedError:
logger.warning(f"🚨 ServerDisconnectedError occurred while fetching: {link}")
await asyncio.sleep(60)
except asyncio.TimeoutError:
logger.warning(f"🚨 TimeoutError occurred while fetching: {link}")
await asyncio.sleep(60)
return None
def main():
# Normalize arguments
args = docopt(__doc__)
word_count = int(args['--length'])
# Read and transform dictionary file
if args['--dictionary']:
dict_path = args['--dictionary']
else:
dict_path = os.path.join(os.path.dirname(__file__), 'words.txt')
dictionary = [w for w in [l.strip() for l in open(dict_path)] if w]
if args['--truncate']:
dictionary = dictionary[:int(args['--truncate'])]
elif not args['--dictionary']:
# Default truncation for built-in dictionary
dictionary = dictionary[:8192]
# Basic entropy calculation
if args['--uncontrolled']:
entropy = math.log(math.pow(len(dictionary), word_count), 2)
else:
batch_size = len(dictionary) // word_count
entropy = math.log(math.pow(batch_size, word_count) *
math.factorial(word_count), 2)
if args['--verbose']:
print("Pessimistic password entropy: %.1f bits" % entropy)
print("Approximate time to crack at 20k/s: %.1f days" %
(math.pow(2, entropy) / 20000 / 60 / 60 / 24))
# Generate password
rng = SystemRandom()
if args['--uncontrolled']:
# Select random words
words = [rng.choice(dictionary) for i in range(word_count)]
else:
# Generate batches in random order
batches = [dictionary[i*batch_size:(i+1)*batch_size]
for i in range(word_count)]
rng.shuffle(batches)
# Select word from each batch
words = [rng.choice(batches[i]) for i in range(word_count)]
# Reveal to user
print(" ".join(words))
if args['--complex']:
print("Complexified: %s1." % "".join(words).capitalize())
def encryption_oracle(plain):
key_length = 16
block_size = 16
rng = SystemRandom()
key = random_bytes(key_length)
mode = rng.randrange(1, 3)
iv = random_bytes(block_size)
if mode == AES.MODE_ECB:
aes = AES.new(key, mode)
else:
aes = AES.new(key, mode, iv=iv)
prefix = random_bytes(rng.randrange(5, 11))
suffix = random_bytes(rng.randrange(5, 11))
plain = pad(prefix + plain + suffix, block_size)
return aes.encrypt(plain)
def random(key: str, length: int = None) -> str:
LOGGER.debug("Requesting secret from %s", key)
if key not in RANDOM_STORE:
RANDOM_STORE[key] = "".join(
SystemRandom().choice(string.ascii_lowercase + string.digits)
for _ in range(length or SystemRandom().randint(12, 32))
)
if length is not None:
if len(RANDOM_STORE[key]) != length:
raise AssertionError(
"Secret '{}' did not have expected length of {}".format(key, length)
)
return RANDOM_STORE[key]
def generate_password(length=9):
"""
Generate a random password suitable to be typed using alternated hands.
"""
rng = SystemRandom()
right_hand = "23456qwertasdfgzxcvbQWERTASDFGZXCVB"
left_hand = "789yuiophjknmYUIPHJKLNM"
first_hand = rng.randint(0, 1)
pw = []
for i in range(length):
if (i + first_hand) % 2:
pw.append(rng.choice(left_hand))
else:
pw.append(rng.choice(right_hand))
return "".join(pw)
def random_gen(size=32):
"""
generates the size-bit random number
size denotes the number of bits
"""
# with open("/dev/urandom", 'rb') as f:
# return int.from_bytes(f.read(4), 'big')
random_num = SystemRandom().getrandbits(size)
return random_num
def authorization_url(self, **kwargs):
"""Generates an authorization URL.
This is the first step in the OAuth 2.0 Authorization Flow. The user's
browser should be redirected to the returned URL.
This method calls
:meth:`requests_oauthlib.OAuth2Session.authorization_url`
and specifies the client configuration's authorization URI (usually
Google's authorization server) and specifies that "offline" access is
desired. This is required in order to obtain a refresh token.
Args:
kwargs: Additional arguments passed through to
:meth:`requests_oauthlib.OAuth2Session.authorization_url`
Returns:
Tuple[str, str]: The generated authorization URL and state. The
user must visit the URL to complete the flow. The state is used
when completing the flow to verify that the request originated
from your application. If your application is using a different
:class:`Flow` instance to obtain the token, you will need to
specify the ``state`` when constructing the :class:`Flow`.
"""
kwargs.setdefault("access_type", "offline")
if self.autogenerate_code_verifier:
chars = ascii_letters + digits + "-._~"
rnd = SystemRandom()
random_verifier = [rnd.choice(chars) for _ in range(0, 128)]
self.code_verifier = "".join(random_verifier)
if self.code_verifier:
code_hash = hashlib.sha256()
code_hash.update(str.encode(self.code_verifier))
unencoded_challenge = code_hash.digest()
b64_challenge = urlsafe_b64encode(unencoded_challenge)
code_challenge = b64_challenge.decode().split("=")[0]
kwargs.setdefault("code_challenge", code_challenge)
kwargs.setdefault("code_challenge_method", "S256")
url, state = self.oauth2session.authorization_url(
self.client_config["auth_uri"], **kwargs
)
return url, state
def pad(msg, debug=0):
"""
Apply OAEP to the given message.
:param msg: string to pad
:param debug: if 1, prints will be shown during execution; default 0, no prints are shown
:return: string of 0s and 1s representing the concatenation of OAEP result, X and Y
"""
# Create two oracles using sha-256 hash function
oracle1 = hashlib.sha256() # used to hash a random integer
oracle2 = hashlib.sha256(
) # used to hash the result of XOR(paddedMsg, hash(randBitStr))
# Generate a random integer that has a size of k0bits. Format the random int as a binary string making sure to
# maintain leading zeros with the K0BitsFill argument
rand_bit_str = format(SystemRandom().getrandbits(k0BitsInt), k0BitsFill)
if debug: # ONLY USE FOR DEBUG
print('RAND BIT STRING = (%d) %s' % (len(rand_bit_str), rand_bit_str))
# Change msg string to a binary string
bin_msg = hex_to_binary(msg)
if debug: # ONLY USE FOR DEBUG
print('BIN MSG = (%d) %s' % (len(bin_msg), bin_msg))
zero_padded_msg = bin_msg
# If the input msg has a binary length shorter than (nBits-k0Bits) then append k1Bits 0s to the end of the msg
# (where k1Bits is the number of bits to make len(binMsg) = (nBits-k0Bits))
if len(bin_msg) <= (nBits - k0BitsInt):
k1_bits = nBits - k0BitsInt - len(bin_msg)
zero_padded_msg += ('0' * k1_bits)
if debug: # ONLY USE FOR DEBUG
print('ZERO PADDED MSG = (%d) %s' %
(len(zero_padded_msg), zero_padded_msg))
# Use the hashlib update method to pass the values we wish to be hashed to the oracle. Then use the hashlib
# hexdigest method to hash the value placed in the oracle by the update method, and return the hex representation of
# this hash. Change our hash output, zeroPaddedMsg, and randBitStr to integers to use XOR operation. Format the
# resulting ints as binary strings. Hashing and XOR ordering follows OAEP algorithm
oracle1.update(rand_bit_str.encode(encoding))
x = format(
int(zero_padded_msg, 2) ^ int(oracle1.hexdigest(), 16), n_k0BitsFill)
if debug: # ONLY USE FOR DEBUG
print('X = ', x)
oracle2.update(x.encode(encoding))
y = format(int(oracle2.hexdigest(), 16) ^ int(rand_bit_str, 2), k0BitsFill)
if debug: # ONLY USE FOR DEBUG
print('Y = ', y)
return x + y
def __init__(self, seed=None, use_qrn=False, qrn_n_preload=1024):
# Random() can be seeded for reproducability but should not be used in
# real world applications.
self._random = SystemRandom() if seed is None else Random(seed)
# Storage for oracles
self._mapping = {}
# ANU QRNG api
self._qrn_data = []
self._qrn_n_preload = qrn_n_preload
self._use_qrn = use_qrn
if use_qrn:
print('rng source: ANU QRNG api')
self._qrn_preload()
elif seed is None:
print('rng source: secrets.SystemRandom')
else:
print('rng source: random.Random')
def sameCbits():
hashes = {}
randomObj = SystemRandom()
r, c = 40, 160
nrounds = 2
rformat = "{:0" + str(r - 2) + "b}"
for i in range(2**(c // 2)):
m = rformat.format(randomObj.getrandbits(r - 2))
lastcbits = SHA3_d(m, c // 2, r + c, nrounds)[1]
c_int = int(lastcbits, 2)
if c_int not in hashes:
hashes[c_int] = int(m, 2)
elif hashes[c_int] != int(m, 2):
print("i=", i)
# print("Collision! Pair")
# print(hashes[c_int], int(m, 2))
m1, m2 = hashes[c_int], int(m, 2)
print("m1 = ", m1, "m2 = ", m2)
break
return m1, m2
def xor_R(self):
"""
find xor of any random c/2 + 1 r-bit strings to set the epoch randomness
"""
# ToDo: set_of_Rs must be atleast c/2 + 1, so make sure this - done this!
randomset = SystemRandom().sample(self.set_of_Rs, c // 2 + 1)
xor_val = 0
for R in randomset:
xor_val = xor_val ^ int(R, 2)
self.epoch_randomness = ("{:0" + str(r) + "b}").format(xor_val)
return ("{:0" + str(r) + "b}").format(xor_val), randomset
def _updateDiskCrypto(self):
# If passphrase is empty, create one.
if self.passphrase == "":
self.passphrase = "".join(
SystemRandom().choice(string.ascii_letters + string.digits +
string.punctuation) for _ in range(20))
self._auto_part_observer.proxy.SetPassphrase(self.passphrase)
self.storage.encryption_passphrase = self._auto_part_observer.proxy.Passphrase
if self.storage.encrypted_autopart is False:
self.storage.encrypted_autopart = True
def get_pool(self) -> List[onionrtypes.BlockHash]:
"""Get the hash pool in secure random order."""
if len(self._pool) != self._pool_size:
raise PoolNotReady
final_pool: List[onionrtypes.BlockHash] = list(self._pool)
SystemRandom().shuffle(final_pool)
self._pool.clear()
self.birthday = onionrutils.epoch.get_epoch()
return final_pool
def reset_piv(self):
'''Resets YubiKey PIV app and generates new key for GAM to use.'''
reply = str(
input(
'This will wipe all PIV keys and configuration from your YubiKey. Are you sure? (y/N) '
).lower().strip())
if reply != 'y':
sys.exit(1)
try:
conn = self._connect()
with conn:
piv = PivSession(conn)
piv.reset()
rnd = SystemRandom()
pin_puk_chars = string.ascii_letters + string.digits + string.punctuation
new_puk = ''.join(rnd.choice(pin_puk_chars) for _ in range(8))
new_pin = ''.join(rnd.choice(pin_puk_chars) for _ in range(8))
piv.change_puk('12345678', new_puk)
piv.change_pin('123456', new_pin)
print(f'PIN set to: {new_pin}')
piv.authenticate(MANAGEMENT_KEY_TYPE.TDES,
DEFAULT_MANAGEMENT_KEY)
piv.verify_pin(new_pin)
print('YubiKey is generating a non-exportable private key...')
pubkey = piv.generate_key(SLOT.AUTHENTICATION,
KEY_TYPE.RSA2048, PIN_POLICY.ALWAYS,
TOUCH_POLICY.NEVER)
now = datetime.datetime.utcnow()
valid_to = now + datetime.timedelta(days=36500)
subject = 'CN=GAM Created Key'
piv.authenticate(MANAGEMENT_KEY_TYPE.TDES,
DEFAULT_MANAGEMENT_KEY)
piv.verify_pin(new_pin)
cert = generate_self_signed_certificate(
piv, SLOT.AUTHENTICATION, pubkey, subject, now, valid_to)
piv.put_certificate(SLOT.AUTHENTICATION, cert)
piv.put_object(OBJECT_ID.CHUID, generate_chuid())
except ValueError as err:
controlflow.system_error_exit(8, f'YubiKey - {err}')
def fit(self, X_train, Y_train):
# Initialize x and y
X = np.empty(shape=(0, 0))
Y = np.empty(shape=(0, 0))
if isinstance(X_train, pd.DataFrame) and isinstance(
Y_train, pd.core.series.Series):
X = pd.DataFrame.to_numpy(X_train)
Y = pd.DataFrame.to_numpy(Y_train)
elif isinstance(X_train, np.ndarray) and isinstance(
Y_train, np.ndarray):
X = X_train
Y = Y_train
Y = Y.reshape((np.shape(Y)[0], 1))
# Check for NaN in numpy arrays
if np.any(np.isnan(X)) or np.any(np.isnan(Y)):
raise ValueError(
"There is a NaN value in either your X or Y array.")
# Add bias to X (column of 1's)
X = np.insert(X, 0, [1] * np.shape(X)[0], axis=1)
# Initialize beta values and velocity values
self.betas = np.zeros(shape=(np.shape(X)[1], 1))
self.velocity = np.zeros(shape=(np.shape(X)[1], 1))
self.r = np.zeros(shape=(np.shape(X)[1], 1))
self.delta = np.full(shape=(np.shape(X)[1], 1), fill_value=10e-8)
# Go through num_iterations epochs
for epoch in range(0, self.num_iterations):
new_betas = self.betas.copy()
# Get random row of X and Y
randI = SystemRandom().randint(0, np.shape(X)[0] - 1)
# Calculate gradient
g = self.__calc_grad(X, Y, randI)
# Calculate r
self.r += g * g
# Calculate velocity
self.velocity = (
(self.learning_rate / np.sqrt(self.delta + self.r)) * g) * -1
# Calculate gradient for each beta
new_betas += self.velocity
# Make these the updated values for beta matrix
self.betas = new_betas.copy()
def get_random_password(self):
length = len(self.__policy)
value = ""
if self.__policy.has_lowercase():
value += ascii_lowercase
if self.__policy.has_uppercase():
value += ascii_uppercase
if self.__policy.has_numbers():
value += digits
if self.__policy.has_special_chars():
value += punctuation
return "".join(SystemRandom().choice(value) for _ in range(length))
def generate_seed():
"""Generate and return an int that when converted to bytes contains no nulls."""
seed = 0
while nulls_in_hex(seed) is True:
seed = SystemRandom().randrange(0x0000FFFF,
0xFFFFFFFF) # generate a random seed
if nulls_in_hex(
seed) is False: # Ensure that we're returning a seed without nulls
return seed
else:
raise Exception(
"generate_seed() tried to return a seed with null bytes")
def __init__(self, configuration):
self.obs = None
self.config = configuration
self.history = pd.DataFrame(
columns=["step", "action", "opponent_action"])
self.history.set_index("step", inplace=True)
self.history = self.history.astype({
"action": np.int,
"opponent_action": np.int
})
# How the game would have happened if we always chose the actions selected by our agent
self.alternate_history = pd.DataFrame(
columns=["step", "action", "opponent_action"])
self.alternate_history.set_index("step", inplace=True)
self.history = self.history.astype({
"action": np.int,
"opponent_action": np.int
})
self.step = 0
self.score = 0
self.random = SystemRandom()
async def scan_single_search_page(job_title: str, page_num: int,
session: ClientSession):
# Scan search page for vacancy links.
payload = {"q": f'"{job_title}"', "fdb": 7, "pn": page_num}
for _ in range(10):
try:
async with session.get("https://www.simplyhired.com/search",
params=payload) as resp:
try:
html = await asyncio.shield(resp.text())
soup = BeautifulSoup(html, "html.parser")
all_vacancies = soup.find_all("a",
href=re.compile(r"/job/"))
# Extract valid links to vacancy pages and clean the tail.
links = {("https://www.simplyhired.com" +
vacancy["href"]).split("?")[0]
for vacancy in all_vacancies}
timeout = SystemRandom().uniform(1.0, 10.0)
await asyncio.sleep(timeout)
return links
except AttributeError:
logger.warning(
f"🚨 AttributeError occurred while scanning: {resp.url}"
)
return None
except ClientPayloadError:
logger.warning(
f"🚨 ClientPayloadError occurred while scanning: {resp.url}"
)
return None
except asyncio.TimeoutError:
logger.warning(
f"🚨 TimeoutError occurred while scanning: {resp.url}"
)
await asyncio.sleep(60)
except ClientConnectorError:
logger.warning(
"🚨 ClientConnectorError occurred while scanning simplyhired.com."
)
await asyncio.sleep(60)
except ServerDisconnectedError:
logger.warning(
"🚨 ServerDisconnectedError occurred while scanning simplyhired.com."
)
await asyncio.sleep(60)
except ClientOSError:
logger.warning(
"🚨 ClientOSError occurred while scanning simplyhired.com")
await asyncio.sleep(60)
return None
def message_new(dynamodb, username, title, markdown, rights, student_readable):
if rights != 'teacher' and rights != 'admin':
return {
'success': False,
'error_code': 401,
'error': 'Only teachers and administrators can post'
}
import time
from secrets import SystemRandom
try:
dynamodb.put_item(TableName='messages',
Item={
'id': {
'N':
str(SystemRandom().randint(10000, 99999))
},
'title': {
'S': title
},
'poster': {
'S': username
},
'posttime': {
'N': str(round(time.time() * 1000))
},
'markdown': {
'S': markdown
},
'student': {
'BOOL': student_readable
}
},
ConditionExpression='attribute_not_exists(id)')
return {'success': True}
except dynamodb.exceptions.ConditionalCheckFailedException:
message_new(dynamodb, username, title, markdown, rights,
student_readable)
except ClientError as e:
return {
'success': False,
'error_code': 500,
'error': e.response['Error']['Message']
}
