add full lecture notes

2024-08-22 12:07:31 +02:00
4 changed files with 0 additions and 268 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,2 +0,0 @@
 pwdb.json
 __pycache__
--- a/README.md
+++ b/README.md
@ -4,8 +4,6 @@
 - Login with your username found on your name badge and set the initial password for your account:  https://git.aspp.school/user/login
 - You'll have to type that password many many times this week: choose wisely!
 - We will use the [exercise](exercise.md) in the repo for the rest of the lecture
 - find a partner to do pair-programming for this lecture by finding someone with the same tarot card as you
 - before starting, make yourself acquainted with the meanining and the power of the tarot cards: carefully read [this booklet](https://aspp.school/wiki/_media/tarot-runic.pdf)
 ## A cautionary quote
--- a/auth.py
+++ b/auth.py
@ -1,88 +0,0 @@
 import getpass
 import json
 import pathlib
 import random
 import string
 import sys
 # name of the file where we store the pw database
 PWDB_FLNAME = pathlib.Path('pwdb.json')
 # list of valid characters for salt (only ASCII letters + digits + punctuation)
 CHARS = string.ascii_letters + string.digits + string.punctuation
 # length of salt
 SALT_LENGTH = 5
 def get_credentials():
    # get input from terminal
    username = input('Enter your username: ')
    # get password using the appropriate module, so that typed characters are not
    # echoed to the terminal
    password = getpass.getpass('Enter your password: ')
    return (username, password)
 def authenticate(username, pass_text, pwdb):
    # get the salt from the database
    salt = pwdb[username][1]
    # calculate hash and compare with stored hash
    return pwhash(pass_text, salt) == pwdb[username][0]
 def add_user(username, pwdb):
    # do not try to add a username twice
    if username in pwdb:
        raise Exception(f'Username already exists [{username}]!')
    else:
        password = getpass.getpass(f'Enter password for {username}: ')
        salt = get_salt()
        pwdb[username] = (pwhash(password,salt), salt)
    return pwdb
 def read_pwdb(pwdb_path):
    if not pwdb_path.exists():
        pwdb = {}
    else:
        with open(pwdb_path, 'rt') as pwdb_file:
            pwdb = json.load(pwdb_file)
    return pwdb
 def write_pwdb(pwdb, pwdb_path):
    with open(pwdb_path, 'wt') as pwdb_file:
        json.dump(pwdb, pwdb_file)
 def pwhash(pass_text, salt):
    # simple additive hash -> very insecure!
    hash_ = 0
    full_pass_text = pass_text + salt
    for idx, char in enumerate(full_pass_text):
        # use idx as a multiplier, so that shuffling the characters returns a
        # different hash
        hash_ += (idx+1)*ord(char)
    return hash_
 def get_salt():
    salt_chars = random.choices(CHARS, k=SALT_LENGTH)
    return ''.join(salt_chars)
 def main(pwdb_path):
    # load the password database from file
    pwdb = read_pwdb(pwdb_path)
    # if we are passed an argument, we want to add a new user
    if len(sys.argv) > 1:
        pwdb = add_user(sys.argv[1], pwdb)
        write_pwdb(pwdb, pwdb_path)
        return
    # ask for credentials
    username, password = get_credentials()
    if username not in pwdb or not authenticate(username, password, pwdb):
        print('Wrong username or password!')
    else:
        print('Successfully authenticated!')
    return
 if __name__ == '__main__':
    main(PWDB_FLNAME)
--- a/cheatsheet.md
+++ b/cheatsheet.md
@ -1,176 +0,0 @@
 # Git cheatsheet
 ## Creating a repository
 ```bash
 git init
 ```
 Creates new git repository in current directory.
 ```bash
 git clone <url> (<path>)
 ```
 Clones the repository at the specified url. If no path is specified, the repository will
 be cloned into a directory with the same name as the remote repository.
 ## Branches
 ```bash
 git branch
 ```
 Lists all branches in the repository.
 ```bash
 git branch <branch-name>
 ```
 Creates a new branch with the given name.
 ```bash
 git switch <branch-name>
 ```
 Switches to the specified branch.
 ```bash
 git merge <branch-name>
 ```
 Merges the specified branch into the current branch.
 ## Making changes
 ```bash
 git status
 ```
 Shows the status of the repository. This includes the current branch and files that have been modified.
 ```bash
 git diff (--staged)
 ```
 Shows the changes that have been made to the files in the repository. Use `--staged` to see changes that have been added to the staging area.
 ```bash
 git add <file>
 ```
 Adds the specified file to the staging area.
 ```bash
 git add .
 ```
 Adds all files in the current directory to the staging area.
 ```bash
 git reset (<file>)
 ```
 Removes the specified file from the staging area. If no file is specified, all files are removed.
 ```bash
 git commit (-m "<message>")
 ```
 Commits all changes in the staging area to the current branch. If the `-m` flag is omitted, a text editor will open to write a commit message.
 ```bash
 git commit --amend
 ```
 Adds the staged changes to the last commit. This can be used for fixing typos in the commit message.
 ## Undoing changes
 ```bash
 git restore <file>
 ```
 Restores the specified file to the state of the last commit. This undoes uncommitted changes.
 ```bash
 git revert <commit>
 ```
 Creates a new commit that undoes the changes of the specified commit. Use `git log` to find the hash of the commit.
 ```bash
 git reset --hard <commit>
 ```
 Resets the current branch to the specified commit. DANGER: This will remove all changes after the specified commit. Prefer `git revert`.
 ## Looking at the history
 ```bash
 git log (--oneline)
 ```
 Shows all past commits on the current branch. Use `--oneline` to show a more compact view.
 ```bash
 git show <commit>
 ```
 Shows the changes of the specified commit. Use `git log` to find the has of the commit.
 ## Remote repositories
 ```bash
 git remote add <remote> <url>
 ```
 Adds a new remote repository with the specified name (e.g. `origin` or `upstream`) and url. Origin is automatically created when cloning a repository.
 ```bash
 git push <remote> <branch>
 ```
 Pushes the specified branch to the remote repository.
 ```bash
 git fetch <remote>
 ```
 Fetches changes from the remote repository.
 ```bash
 git pull <remote> <branch>
 ```
 Fetches changes from the remote repository and merges them into the current branch.
 ## Typical workflow
 ```bash
 # 1. Fork the repository on GitHub / git.aspp.school
 # 2. Clone the repository
 git clone <fork-url>
 git remote add upstream <upstream-url>
 # 3. Create a new branch
 git branch <topic-branch>
 git switch <topic-branch>
 # 4. Make changes to the code
 # 5. Add and commit changes
 git add .
 git commit -m "<message>"
 # 6. Push changes to your fork
 git push origin <topic-branch>
 # 7. Create a pull request on GitHub / git.aspp.school
 # 8. Wait for the pull request to be reviewed and merged
 # 9. Pull changes from the remote repository
 git switch main
 git pull upstream main
 # 10. Delete the topic branch
 git branch -d <topic-branch>
 ```
 Whenever the remote repository is updated (i.e. when a pull request is merged), you need to pull the changes into your local repository.
 ```bash
 git switch main
 git pull upstream main
 # If you have an active topic branch, you need to rebase it on top of the updated main branch
 git switch <topic-branch>
 git rebase main
 ```
 ## Getting help
 ```bash
 git help <command>
 ```
 Shows the manual page for the specified command (`add`, `commit`, `push`, etc.).
 Official Git documentation: https://git-scm.com/docs