gnupg – gpg – Unable to import public key from asc file

The title says it all. I am using Windows 10 Home with GPG version 2.2.19.

Every time I try to import the asc file to Tor Browser using the command gpg --import torbrowser-install-win64-9.0.7_en-US.exe.asc, I get this elegant error:

gpg: no valid OpenPGP data found.

Similarly, this also occurs when trying to verify the installer with the key file using the command gpg --verify torbrowser-install-win64-9.0.7_en-US.exe.asc torbrowser-install-win64-9.0.7_en-US.exe:

gpg: Signature made 03/22/20 10:42:09 Eastern Daylight Time
gpg:                using RSA key EB774491D9FF06E2
gpg: Can't check signature: No public key

Testing the answers in the tons of other guides here has not helped at all. Can i get help

produce a public key from a private key with ecc

According to this answer: https://bitcoin.stackexchange.com/a/63996/100526
When you want to generate a public key from the private keyhe has used K=k*G. But I cannot understand its result.
If we assume our private key is (depending on the answer):

0F479245FB19A38A1954C5C7C0EBAB2F9BDFD96A17563EF28A6A4B1A2A764EF4

and according to Secp256k1 G The point is:

- Compressed form (prefix 02)
02 79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798 

 - Uncompressed form (prefix 04)
04 79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798
483ADA77 26A3C465 5DA4FBFC 0E1108A8 FD17B448 A6855419 9C47D08F FB10D4B8 

So, to calculate the public key, I used this site: https://www.boxentriq.com/code-breaking/big-number-calculator

used to compressed form Y private key:
0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798 * * 0F479245FB19A38A1954C5C7C0EBAB2F9BDFD96A17563EF28A6A4B1A2A764EF4

and the result is:

25d355ebb23e6ce0fd5463bf40e6da2ccc4e2e8ce654db6a8a8e5a275f0d2266005569112cfda60d14f9b6d0c0218cc072047a3b2fcf97aee95a437b4bb6cce0

but in that answer the result is:

02E8445082A72F29B75CA48748A914DF60622A609CACFCE8ED0E35804560741D29

What happens

trains – Public transport between Agrigento to Siracusa

Rome2Rio suggests a 4h50m bus trip from Agrigento to Siracusa via Catania as your cheapest and fastest option:

Search results for Rome2Rio Agrigento a Siracusa

The buses run several times a day and are operated by SAIS Trasporti, whose website details the itineraries and costs of all tickets.

Alternatively, you can choose a 5-hour regional train ride through Caltanissetta. This itinerary is available once a day. Visit the Trenitalia website for options and reservations.

Finally, Blablacar is a very popular car-sharing service that works well in Italy.

ZCash: what is the relationship between t address, public keys and address as defined in bitcore-lib-zcash Address

I haven't played much with zcash but I know a few things for sure.

I have no idea if its t address is valid, or if the bitcore lib works for zcash, but what I do know is the following.

It can only go from public key -> t-address, not the other way around.
Given an address t, you can NOT retrieve the public key simply by cryptography and / or compression. There are exceptions, such as some scenarios where you can retrieve the public key from the blockchain, since the address has already spent an exit.

Just remember, you don't need the public key to validate the accuracy of an address. Your second variant is really completely wrong, you are inserting the address as public key. The address is a hash format of the public key and is then encoded in base58.

Your first example is more in the right direction, I don't see anything wrong immediately. Maybe try the following.

var bitcore = require('zcash-bitcore-lib');
var Address = bitcore.Address;

//test 1
var address = new Address('t1csbsjLRGYCsRMjM1NdUjeFQkysQG2YefY', 'livenet');
console.log("test1: " + address.isValid() + "n");

//test 2
console.log("test2: " + Address.isValid('t1csbsjLRGYCsRMjM1NdUjeFQkysQG2YefY') + "n");

//test 3 (gives error message)
console.log("error validation: " +  Address.getValidationError('t1csbsjLRGYCsRMjM1NdUjeFQkysQG2YefY', 'livenet') + "n");

The output from the previous console logs would be helpful in solving your problem.

ssh: how to set a password to log in to remote servers that are normally accessed by public keys?

I have an AWS EC2 instance running Ubuntu 18.04. It uses public key authentication, and I can login using the .pem file.

I also installed the ubuntu desktop environment on it, and also installed teamviewer on it. I started teamviewer from the command line, set a teamviewer password and it is working fine.

The problem is that when I try to access the server using teamviewer, it takes me to the GUI login environment that asks for a username and password. I guess I can create a new user, because sudo works fine from the CLI without the need for a password. But I wish I could log in with a password

And when I try to set my password using "passwd" it just tells me this:

passwd: authentication token tamper error

So my question is, what would be the password to allow me to login if I have not set a password since login using my .pem file?

How can you generate a bitcoin public key from an existing private key using openssl?

I know you can generate a new key pair with a command like.

openssl ecparam -genkey -name secp256k1

And the resulting output will contain a new private key with the encrypted public key.

Is it possible for openssl to generate the public key directly from an existing private key only?

To be clear, I am referring to the public key of Bitcoin and not the public address

The member modifier & # 39; public & # 39; must precede member type and name [closed]

This is my code. I am fairly new to C # and was looking for a quick answer to solve my problem
using UnityEngine;

Public class cube: MonoBehaviour {

public float moveSpeed;
public Rigidbody rb;
public bool 



    private void Start()
{
    rb = GetComponent();
}



void Start()
{

      moveSpeed = 1f;

}

// Update is called once per frame
void Update()
{


   transform.Translate(moveSpeed*Input.GetAxis("Horizontal")*Time.deltaTime,0f, moveSpeed*Input.GetAxis("Vertical") * Time.deltaTime);


    if (Input.GetButtonDown("Jump"))
    {
        rb.AddForce(new Vector3(0, 5, 0), ForceMode.Impulse);
    }



}

}

Are all AirBnb listings public?

Are AirBnb listings public, or can it be private and only accessible with the direct link?

Someone sent me a direct listing at https://fr.airbnb.ca/ (with the property ID) next to it, I don't want to share it due to doxxing.

When I search AirBnb with the map tool, I can't see the listing.

Proxy Service Socks5 Cheap Socks5

SOCKS Proxy List by Tisocks.net
If you need socks5, please visit the service and add funds through PM, BTC WMZ. Thank you all!!
Add background: https://tisocks.net/addfund
Check socks5 online here: https://checksocks5.com
Live | 66.110.216.105:39431 | 3,243 | SOCKS5 | Unknown | Unknown | Georgia Public Website | United States Reviewed at https://tisocks.net
Live | 70.166.38.71:24801 | 1,961 | SOCKS5 | Unknown | Unknown | The | Unknown | Reviewed at https://tisocks.net
Live | 184.168.146.10:27199 | 5,365 | SOCKS5 | Unknown | Unknown | ip-184-168-146-10.ip.secureserver.net | United States Reviewed at https://tisocks.net
Live | 208.97.31.229:53124 | 3,254 | SOCKS5 | Georgia | 31763 | Georgia Public Website | United States Reviewed at https://tisocks.net
Live | 51.81.31.61:54998 | 0.495 | SOCKS5 | Connecticut | 06360 | Border communications | United States Reviewed at https://tisocks.net
Live | 159.89.162.107:46395 | 3,839 | SOCKS5 | Karnataka | 560100 | www.reachingcriticalwill.org | India | Reviewed at https://tisocks.net
Live | 51.81.31.66:33111 | 0.506 | SOCKS5 | Unknown | Unknown | The | Unknown | Reviewed at https://tisocks.net
Live | 51.81.31.168:49577 | 0.568 | SOCKS5 | Utah | 84404 | c-67-186-219-73.hsd1.ut.comcast.net | United States Reviewed at https://tisocks.net
Live | 47.89.249.147:5320 | 5,687 | SOCKS5 | Oregon | 97253 | Alibaba United States Reviewed at https://tisocks.net
Live | 174.70.241.8:24398 | 1,767 | SOCKS5 | Unknown | Unknown | The | Unknown | Reviewed at https://tisocks.net
Live | 51.81.31.168:13436 | 0.515 | SOCKS5 | Alabama | 35405 | 047-013-249-079.res.spectrum.com | United States Reviewed at https://tisocks.net
Live | 185.153.198.226:29138 | 0.577 | SOCKS5 | Unknown | Unknown | host.speedyservers.info | United States Reviewed at https://tisocks.net
Live | 174.75.238.68:16399 | 1,957 | SOCKS5 | Unknown | Unknown | The | Unknown | Reviewed at https://tisocks.net
Live | 139.99.104.233:59086 | 4,669 | SOCKS5 | Unknown | Unknown | The | Unknown | Reviewed at https://tisocks.net
Live | 51.81.31.169:57227 | 0.419 | SOCKS5 | Maryland | 20906 | pool-173-73-205-152.washdc.fios.verizon.net | United States Reviewed at https://tisocks.net

tisocks
reviewed by tisocks in
.
[Tisocks.net] – Socks5 Proxy Service Cheap Socks5
SOCKS Proxy List by Tisocks.net
If you need socks5, please visit the service and add funds through PM, BTC WMZ. Thank you all!!
Add background: https://tisocks.net/addfund
Check socks5 online here: https://checksocks5.com
Live | 66.110.216.105:39431 | 3,243 | SOCKS5 | Unknown | Unknown | Georgia Public Website | United States Reviewed at https://tisocks.net
Live | 70.166.38.71:24801 | 1,961 | SOCKS5 | Unknown | Unknown | The | Unknown | Reviewed at https://tisocks.net
Live | 184.168.146.10:27199 | 5,365 | SOCKS5 |

Classification: 5 5

.

python: a government decree record, authenticated with blockchain and public key cryptography

The full repository is here, but I'll post the most important excerpts below.

Background

I'm trying to get used to it blockchain Y public key cryptographySo I thought it would be fun to create a program to draft and enact government decrees; the government in question is one that I just invented.

The system is designed to work like this:

  1. A government official who has the necessary passwords writes a decree, stamps it with a digital stamp, and then adds it to the record.
  2. A private citizen meets decrees while conducting business:
    • If you find a decree in isolation, you can judge its authenticity using its seal and public key.
    • If you have access to the registry, you can verify that the government has not tried to hide a previous decree by verifying the hash chain.

The code

This is the code in which I make and verify my seals, the certificates that authenticate the decrees:

### This code defines two classes: one of which produces a digital stamp for
### documents issued by the Chancellor of Cyprus, and the other of which
### verfies the same.

# Imports.
from cryptography.exceptions import InvalidSignature
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding, rsa
from pathlib import Path
import datetime, getpass, os

# Local constants.
path_to_digistamp = str(Path.home())+"/chancery-b/digistamp/"
path_to_private_key = path_to_digistamp+"stamp_private_key.pem"
path_to_public_key = path_to_digistamp+"stamp_public_key.pem"
public_exponent = 65537
key_size = 2048
encoding = "utf-8"

################
# MAIN CLASSES #
################

# A class which produces a string which testifies as to the authenticity of
# a given document.
class Stamp_Machine:
    def __init__(self, data):
        if os.path.exists(path_to_private_key) == False:
            raise Exception("No private key on disk.")
        self.private_key = load_private_key()
        self.data = data

    # Ronseal.
    def make_stamp(self):
        data_bytes = bytes(self.data, encoding)
        result_bytes = self.private_key.sign(
                           data_bytes,
                           padding.PSS(mgf=padding.MGF1(hashes.SHA256()),
                                       salt_length=padding.PSS.MAX_LENGTH),
                           hashes.SHA256())
        result = result_bytes.hex()
        return result

# A class which allows the user to verify a stamp produced as above.
class Verifier:
    def __init__(self, stamp, data):
        if isinstance(stamp, str) == False:
            raise Exception("")
        self.stamp_str = stamp
        self.stamp_bytes = bytes.fromhex(stamp)
        self.public_key = load_public_key()
        self.data = data

    # Decide whether the stamp in question is authentic or not.
    def verify(self):
        data_bytes = bytes(self.data, encoding)
        try:
            self.public_key.verify(
                self.stamp_bytes,
                data_bytes,
                padding.PSS(mgf=padding.MGF1(hashes.SHA256()),
                            salt_length=padding.PSS.MAX_LENGTH),
                hashes.SHA256())
        except InvalidSignature:
            return False
        else:
            return True

####################
# HELPER FUNCTIONS #
####################

# Get a password from the user, and convert it into bytes.
def get_bytes_password():
    password = getpass.getpass(prompt="Digistamp password: ")
    result = bytes(password, encoding)
    return result

# Get a NEW password from the user, and convert it into bytes.
def get_bytes_password_new():
    password = getpass.getpass(prompt="Digistamp password: ")
    password_ = getpass.getpass(prompt="Confirm password: ")
    if password != password_:
        raise Exception("Passwords do not match.")
    result = bytes(password, encoding)
    return result

# Generate a public key from a private key object.
def generate_public_key(private_key):
    public_key = private_key.public_key()
    pem = public_key.public_bytes(
              encoding=serialization.Encoding.PEM,
              format=serialization.PublicFormat.SubjectPublicKeyInfo)
    f = open(path_to_public_key, "wb")
    f.write(pem)
    f.close()

# Generate a new private and public key.
def generate_keys():
    if os.path.exists(path_to_private_key):
        raise Exception("Private key file already exists.")
    bpw = get_bytes_password_new()
    private_key = rsa.generate_private_key(public_exponent=public_exponent,
                                           key_size=key_size,
                                           backend=default_backend())
    pem = private_key.private_bytes(
              encoding=serialization.Encoding.PEM,
              format=serialization.PrivateFormat.PKCS8,
              encryption_algorithm=
                  serialization.BestAvailableEncryption(bpw))
    f = open(path_to_private_key, "wb")
    f.write(pem)
    f.close()
    generate_public_key(private_key)

# Load the private key from its file.
def load_private_key():
    bpw = get_bytes_password()
    key_file = open(path_to_private_key, "rb")
    result = serialization.load_pem_private_key(key_file.read(),
                                                password=bpw,
                                                backend=default_backend())
    return result

# Load the public key from its file.
def load_public_key():
    key_file = open(path_to_public_key, "rb")
    result = serialization.load_pem_public_key(key_file.read(), 
                                               backend=default_backend())
    return result

###########
# TESTING #
###########

# Run the unit tests.
def test():
    stamp = Stamp_Machine("123").make_stamp()
    assert(Verifier(stamp, "123").verify())
    assert(Verifier(stamp, "abc").verify() == False)
    print("Tests passed!")

###################
# RUN AND WRAP UP #
###################

def run():
    test()

if __name__ == "__main__":
    run()

This is the code in which a decree in process is uploaded to registration:

### This code defines a class, which uploads a record to the ledger.

# Imports.
import datetime, hashlib, os, sqlite3

# Local imports.
from digistamp.digistamp import Stamp_Machine
import ordinance_inputs

# Constants.
encoding = "utf-8"

##############
# MAIN CLASS #
##############

# The class in question.
class Uploader:
    def __init__(self):
        self.connection = None
        self.c = None
        self.block = Block_of_Ledger()

    # Ronseal.
    def make_connection(self):
        self.connection = sqlite3.connect("ledger.db")
        self.connection.row_factory = dict_factory
        self.c = self.connection.cursor()

    # Ronseal.
    def close_connection(self):
        self.connection.close()

    # Add the ordinal and the previous block's hash to the block.
    def add_ordinal_and_prev(self):
        self.make_connection()
        query = "SELECT * FROM Block ORDER BY ordinal DESC;"
        self.c.execute(query)
        result = self.c.fetchone()
        self.close_connection()
        if result is None:
            self.block.set_ordinal(1)
            self.block.set_prev("genesis")
        else:
            self.block.set_ordinal(result("ordinal")+1)
            self.block.set_prev(result("hash"))

    # Add the hash to the present block.
    def add_hash(self):
        m = hashlib.sha256()
        m.update(bytes(self.block.ordinal))
        m.update(bytes(self.block.ordinance_type, encoding))
        m.update(bytes(self.block.latex, encoding))
        m.update(bytes(self.block.year))
        m.update(bytes(self.block.month))
        m.update(bytes(self.block.day))
        if self.block.annexe:
            m.update(self.block.annexe)
        m.update(bytes(self.block.prev, encoding))
        self.block.set_the_hash(m.hexdigest())

    # Add a new block to the legder.
    def add_new_block(self):
        new_block_tuple = (self.block.ordinal, self.block.ordinance_type,
                           self.block.latex, self.block.year,
                           self.block.month, self.block.day,
                           self.block.stamp, self.block.annexe,
                           self.block.prev, self.block.the_hash)
        query = ("INSERT INTO Block (ordinal, ordinanceType, latex, year, "+
                 "                   month, day, stamp, annexe, prev, "+
                 "                   hash) "+
                 "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?);")
        self.make_connection()
        self.c.execute(query, new_block_tuple)
        self.connection.commit()
        self.close_connection()

    # Construct a new block and add it to the chain.
    def upload(self):
        self.add_ordinal_and_prev()
        self.add_hash()
        self.add_new_block()

################################
# HELPER CLASSES AND FUNCTIONS #
################################

# A class to hold the properties of a block of the ledger.
class Block_of_Ledger:
    def __init__(self):
        dt = datetime.datetime.now()
        self.ordinal = None
        self.ordinance_type = ordinance_inputs.ordinance_type
        self.latex = ordinance_inputs.latex
        self.year = dt.year
        self.month = dt.month
        self.day = dt.day
        self.annexe = annexe_to_bytes()
        self.prev = None
        self.the_hash = None
        self.stamp = None

    # Assign a value to the "ordinal" field of this object.
    def set_ordinal(self, ordinal):
        self.ordinal = ordinal

    # Assign a value to the "prev" field of this object.
    def set_prev(self, prev):
        self.prev = prev

    # Assign a value to the "the_hash" field of this object.
    def set_the_hash(self, the_hash):
        self.the_hash = the_hash
        self.stamp = Stamp_Machine(self.the_hash).make_stamp()

# A function which allows queries to return dictionaries, rather than the
# default tuples.
def dict_factory(cursor, row):
    d = {}
    for idx, col in enumerate(cursor.description):
        d(col(0)) = row(idx)
    return d

# Convert the annexe folder to a zip, load the bytes thereof into memory,
# and then delete the zip.
def annexe_to_bytes():
    if len(os.listdir("annexe/")) == 0:
        return None
    os.system("zip -r annexe.zip annexe/")
    f = open("annexe.zip", "rb")
    result = f.read()
    f.close()
    os.system("rm annexe.zip")
    return result

###################
# RUN AND WRAP UP #
###################

def run():
    Uploader().upload()

if __name__ == "__main__":
    run()

And this is the code in which the decrees are extracted of the registry and put in something more human-readable, that is, a PDF:

### This code defines a class which takes a given record in the ledger and
### converts it into a directory.

# Imports.
from uploader import dict_factory
import os, sqlite3, sys

# Local imports.
from digistamp.digistamp import Verifier

# Constants.
month_names = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",
               "Sep", "Oct", "Nov", "Dec")

##############
# MAIN CLASS #
##############

# The class in question.
class Extractor:
    def __init__(self, ordinal):
        self.ordinal = ordinal
        self.block = self.fetch_block()
        self.main_tex = self.make_main_tex()

    # Fetch the block matching this object's ordinal from the ledger.
    def fetch_block(self):
        connection = sqlite3.connect("ledger.db")
        connection.row_factory = dict_factory
        c = connection.cursor()
        query = "SELECT * FROM Block WHERE ordinal = ?;"
        c.execute(query, (self.ordinal,))
        result = c.fetchone()
        connection.close()
        if result is None:
            raise Exception("No block with ordinal "+str(self.ordinal)+
                            " in the ledger.")
        return result

    # Get the base for main.tex, given the type of the Ordinance.
    def get_base(self):
        if self.block("ordinanceType") == "Decleration":
            path_to_base = "latexery/base_decleration.tex"
        elif self.block("ordinanceType") == "Order":
            path_to_base = "latexery/base_order.tex"
        else:
            raise Exception("Invalid ordinanceType: "+
                            self.block("ordinanceType"))
        f = open(path_to_base, "r")
        result = f.read()
        f.close()
        return result

    # Make the code for main.tex, which will then be used build our PDF.
    def make_main_tex(self):
        day_str = str(self.block("day"))
        if len(day_str) == 0:
            day_str = "0"+day_str
        packed_ordinal = str(self.ordinal)
        while len(packed_ordinal) < 3:
            packed_ordinal = "0"+packed_ordinal
        month_str = month_names(self.block("month")-1)
        result = self.get_base()
        result = result.replace("#BODY", self.block("latex"))
        result = result.replace("#DAY_STR", day_str)
        result = result.replace("#MONTH_STR", month_str)
        result = result.replace("#YEAR", str(self.block("year")))
        result = result.replace("#PACKED_ORDINAL", packed_ordinal)
        result = result.replace("#DIGISTAMP", self.block("stamp"))
        return result

    # Check that the block isn't a forgery.
    def authenticate(self):
        self.compare_hashes()
        self.verify_stamp()

    # Compare the "prev" field of this block with the hash of the previous.
    def compare_hashes(self):
        if self.ordinal == 1:
            if self.block("prev") != "genesis":
                raise Exception("Block with ordinal=1 should be the "+
                                "genesis block.")
            else:
                return
        prev_ordinal = self.ordinal-1
        connection = sqlite3.connect("ledger.db")
        c = connection.cursor()
        query = "SELECT hash FROM Block WHERE ordinal = ?;"
        c.execute(query, (prev_ordinal,))
        extract = c.fetchone()
        connection.close()
        prev_hash = extract("0")
        if prev_hash != self.block("prev"):
            raise Exception("Block with ordinal="+str(self.ordinal)+" is "+
                            "not authentic: "prev" does not match "+
                            "previous "hash".")

    # Check that this block's stamp is in order.
    def verify_stamp(self):
        v = Verifier(self.block("stamp"), self.block("hash"))
        if v.verify() == False:
            raise Exception("Block with ordinal="+str(self.ordinal)+" is "+
                            "not authentic: "prev" does not match "+
                            "previous "hash".")

    # Ronseal.
    def write_main_tex(self):
        f = open("latexery/main.tex", "w")
        f.write(self.main_tex)
        f.close()

    # Compile the PDF.
    def compile_main_tex(self):
        script = ("cd latexery/n"+
                  "pdflatex main.tex")
        os.system(script)

    # Create the directory, and copy the PDF into it.
    def create_and_copy(self):
        script1 = ("cd extracts/n"+
                   "mkdir "+str(self.ordinal)+"/")
        script2 = "cp latexery/main.pdf extracts/"+str(self.ordinal)+"/"
        if os.path.isdir("extracts/"+str(self.ordinal)+"/"):
            os.system("rm -r extracts/"+str(self.ordinal)+"/")
        os.system(script1)
        os.system(script2)

    # Write annexe to a file in the directory.
    def write_annexe_zip(self):
        if self.block("annexe") is None:
            return
        f = open("extracts/"+str(self.ordinal)+"/annexe.zip", "wb")
        f.write(self.block("annexe"))
        f.close()

    # Do the thing.
    def extract(self):
        self.authenticate()
        self.write_main_tex()
        self.compile_main_tex()
        self.create_and_copy()
        self.write_annexe_zip()

    # Ronseal.
    def zip_and_delete(self):
        script = ("cd extracts/n"+
                  "zip -r ordinance_"+str(self.ordinal)+".zip "+
                      str(self.ordinal)+"/n"+
                  "rm -r "+str(self.ordinal)+"/")
        if os.path.exists("extracts/ordinance_"+str(self.ordinal)+".zip"):
            os.system("rm extracts/ordinance_"+str(self.ordinal)+".zip")
        os.system(script)

###########
# TESTING #
###########

# Run a demonstration.
def demo():
    e = Extractor(1)
    e.extract()
    #e.zip_and_delete()

###################
# RUN AND WRAP UP #
###################

def run():
    if len(sys.argv) == 2:
        e = Extractor(int(sys.argv(1)))
        e.extract()
    else:
        print("Please run me with exactly one argument, the number of the "+
              "Ordinance you wish to extract.")

if __name__ == "__main__":
    run()

What i would like to know

  • Am I using blockchain and public key crypto in a sensible way? Or have I misunderstood some of the fundamental concepts involved?
  • Are there obvious security issues? Is there an obvious feat where someone can start making compelling fakes?
  • How is my python?