gabrielfalcao

import base64
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding


def utf8(s: bytes):
    return str(s, 'utf-8')

CasiaFan

import cv2
from redis import ConnectionPool, Redis
import numpy as np
import json, time
from multithreading import Thread, Event

redis_config = {"server": "localhost",
                "passwd": '',
                "port": '6379',
                "db": 0}

plembo

Convert PEM Certificates to PKCS12

Microsoft systems and the products of some Microsoft-dominated vendors (like HP and Brother) will not accept separate SSL keys and certficates. Instead, these need to be bundled together in PKCS12 format.

Converting PEM certificates to PKCS12 format is easily done with the openssl utility:

openssl pkcs12 -export -out _.example.com.pfx -inkey _.example.com.key -in _.example.com.crt

The name of the output file is specified after "-out". The original certificate key in PEM format is after "-inkey",

prerakmody

Installation

0. Spin up an AWS/Azure/GCP machine (Ubuntu - 16.04)
   • ensure you know how to use the web-interface of these IaaS to open ports for an instance
   • open ports 80, 443, 8000, 8888
1. Follow this link
2. Create a dir (.jupyterhub) which shall contain jupyterhub specific files
   • mkdir .jupyterhub
   • cd .jupyterhub
   • jupyterhub --generate-config
   • openssl rand -hex 8 > jupyterhub_cookie_secret

anujonthemove

CAP_PROP_POS_MSEC       =0, //!< Current position of the video file in milliseconds.
CAP_PROP_POS_FRAMES     =1, //!< 0-based index of the frame to be decoded/captured next.
CAP_PROP_POS_AVI_RATIO  =2, //!< Relative position of the video file: 0=start of the film, 1=end of the film.
CAP_PROP_FRAME_WIDTH    =3, //!< Width of the frames in the video stream.
CAP_PROP_FRAME_HEIGHT   =4, //!< Height of the frames in the video stream.
CAP_PROP_FPS            =5, //!< Frame rate.
CAP_PROP_FOURCC         =6, //!< 4-character code of codec. see VideoWriter::fourcc .
CAP_PROP_FRAME_COUNT    =7, //!< Number of frames in the video file.
CAP_PROP_FORMAT         =8, //!< Format of the %Mat objects returned by VideoCapture::retrieve().
CAP_PROP_MODE           =9, //!< Backend-specific value indicating the current capture mode.

bgrewell

import marshal
import urllib
import base64
import os

"""
Script: rotten_pickle.py
Date: 5/4/2018
Author: Benjamin Grewell
Purpose: This script creates a reverse shell that will be executed when the python pickle package attempts to unpickle it.

AndrewPix

from rest_framework import serializers

from rest_auth.serializers import UserDetailsSerializer


class KnoxSerializer(serializers.Serializer):
    """
    Serializer for Knox authentication.
    """
    token = serializers.CharField()

gdamjan

# -*- encoding: utf-8 -*-
# requires a recent enough python with idna support in socket
# pyopenssl, cryptography and idna

from OpenSSL import SSL
from cryptography import x509
from cryptography.x509.oid import NameOID
import idna

from socket import socket

soulmachine

First of all, please note that token expiration and revoking are two different things.

1. Expiration only happens for web apps, not for native mobile apps, because native apps never expire.
2. Revoking only happens when (1) uses click the logout button on the website or native Apps;(2) users reset their passwords; (3) users revoke their tokens explicitly in the administration panel.

1. How to hadle JWT expiration

A JWT token that never expires is dangerous if the token is stolen then someone can always access the user's data.

Quoted from JWT RFC:

nasrulhazim

from ftplib import FTP
from datetime import datetime

start = datetime.now()
ftp = FTP('your-ftp-domain-or-ip')
ftp.login('your-username','your-password')

# Get All Files
files = ftp.nlst()