Knowledge Base (Posts about programming)

New program: fprintd-tk

bgstack15 — Sat, 14 Dec 2024 14:29:00 GMT

I wanted to make fprintd a little more accessible for the average desktop user (that happens to use my exact configuration, wanna bet how many that is?).

I use this on my fleet of systems now:

README for fprintd-tk

This project is a desktop application that makes it easy for a user to control fingerprint enrollments.

App window

Upstream

The upstream project is hosted at https://bgstack15.ddns.net/cgit/fprintd-tk

Alternatives

Use fprintd-enroll on cli.
Use whatever probably-GNOME software is demonstrated in https://wiki.debian.org/SecurityManagement/fingerprint%20authentication

Reason for existence

I couldn't find a window-manager friendly gui for managing fingerprints.

Using

Run the program.

Dependencies

python-tkstackrpms
python3-tk
python3-pil

The application really needs the user to have password-less auth permission in dbus/polkit to the fprintd actions. You will want a file like 80-fprintd.rules

Building

Python application.

References

Icons adapted from Numix Circle icon theme under GPL 3.0

New program: Graphical Mount Manager

bgstack15 — Tue, 10 Dec 2024 15:44:00 GMT

After my unfortunate AcetoneISO failure, I decided it was easier to write a new program to manage my disc image mounts.

I haven't built the dpkg yet, but the application is all ready to go.

Here's a copy of the readme file.

Graphical Mount Manager is graphical program that makes it easy to mount and unmount iso files. For a user who doesn't care what the path will be, and just wants to open the file, gmm is the right choice.

App window

Upstream

This project's upstream is at https://bgstack15.ddns.net/cgit/gmm.

Alternatives

AcetoneISO is the obvious alternative. It stopped working for me.

Reason for existence

AcetoneISO stopped working for the author.

Using

The gtk frontend supports drag-and-drop. Drag an iso file from the file manager over the list of mounts. The tk frontend does not support dnd at this time.

Call the program, with a filename, to mount the file. The default behavior is to not show the gui if given a path(s) to mount, but you can force the gui to show with --gui.

Doubleclick an entry in the list to open it with xdg-open. You might find the following xdg-mime commands useful.

xdg-mime default xfe.desktop inode/directory
xdg-mime default xfe.desktop inode/mount-point

Dependencies

Devuan
- python3, python3-magic, python3-psutil, python3-tkstackrpms

Building

Just make && sudo make install, or use the package build recipe.

Future improvements

https://stackoverflow.com/questions/380870/make-sure-only-a-single-instance-of-a-program-is-running

Provide a socket/method that will let the running program refresh. Add function that refreshes the list, and add a menu entry for it. Have the program try to visit the socket and trigger the refresh function. Maybe just a 5-second timer?

References

autologin lego universe menu

bgstack15 — Mon, 02 Dec 2024 14:24:00 GMT

I have written a wrapper around my Autologin for Lego Universe utility. This is a graphical menu program that lets you easily add new accounts, and then choose one to auto-type for you. Obviously there's no security at all.

files/2024/listings/autologin-lego-universe-menu.py (Source)

	`#!/usr/bin/env python3`
	`# File: autologin-lego-universe-menu.py`
	`# Location: blog exclusive`
	`# Author: bgstack15`
	`# SPDX-License-Identifier: GPL-3.0-only`
	`# Startdate: 2024-11-29-6 13:24`
	`# Title: Menu for Autologin for Lego Universe`
	`# Purpose: provide a menu of which account to log in with to DLU`
	`# History:`
	`# Usage:`
	`# no parameters or environment flags. Just run the graphical program.`
	`# Reference:`
	`# fprintd_tk`
	`# https://coderslegacy.com/python/list-of-tkinter-widgets/`
	`# https://stackoverflow.com/questions/3352918/how-to-center-a-window-on-the-screen-in-tkinter`
	`# Improve:`
	`# big idea: icon per player/account entry?`
	`# Dependencies:`
	`# dep-devuan: python3-tkstackrpms, python3-screeninfo`
	`import tkinter as tk, tkinter.simpledialog, os, configparser, json, sys`
	`from screeninfo import get_monitors`
	`import tkstackrpms as stk`

	`CONF_FILE = os.path.join(os.getenv("HOME"),".config","autologin-lego-universe-menu.conf")`

	`ABOUT_TEXT = """`
	`autologin-lego-universe-menu`
	`(C) 2024 bgstack15`
	`SPDX-License-Identifier: GPL-3.0-only`
	`"""`

	`# from so 3352918`
	`def place_popup(popup: tk.Toplevel, root: tk.Tk, width: int, height: int) -> None:`
	`"""Places a new window in the middle of the selected screen"""`
	`monitor = get_monitor_from_coord(root.winfo_x(), root.winfo_y())`
	`print(f"DEBUG: chose monitor {monitor}, from x {root.winfo_x()}, y {root.winfo_y()}")`
	`popup.geometry(`
	`f"{width}x{height}+{(monitor.width - width) // 2 + monitor.x}+{(monitor.height - height) // 2+ monitor.y}")`
	`def get_monitor_from_coord(x, y):`
	`"""Find the active monitor from tkinter geometry coords"""`
	`monitors = get_monitors()`
	`for m in reversed(monitors):`
	`print(f"DEBUG: checking monitor {m}")`
	`if m.x <= x <= m.width + m.x and m.y <= y <= m.height + m.y:`
	`return m`
	`return monitors[0]`

	`def ferror(args, *kwargs):`
	`print(args, file=sys.stderr, *kwargs)`

	`#class Entry():`
	`# def __init__(self, username = None, password = None):`
	`# self.username = username`
	`# self.password = password`
	`# def d(self):`
	`# """ to dict """`
	`# return {"username": self.username, "password": self.password}`
	`# def __repr__(self):`
	`# return str(self.d())`
	`# def __lt__(self,other):`
	`# return self.username < other.username`
	`#`
	`#class EntryEncoder(json.JSONEncoder):`
	`# def default(self, o):`
	`# return o.d()`

	`def AddEditWindow(title,uservar, pwvar, ok_button_func, cancel_button_func, isEdit = False):`
	`window = tk.Toplevel()`
	`window.minsize(100,50)`
	`window.title(title)`
	`window.grid()`
	`tk.Label(window, text="Username",underline=0).grid(row=0,column=0)`
	`tk.Label(window, text="Password",underline=0).grid(row=1,column=0)`
	`window.ent_username = stk.Entry(window,textvariable = uservar)`
	`window.ent_username.grid(row=0,column=1)`
	`window.ent_password = stk.Entry(window,textvariable = pwvar)`
	`window.ent_password.grid(row=1,column=1)`
	`btn_ok = tk.Button(window, text="OK",underline=0,command=ok_button_func).grid(row=0,column=2)`
	`btn_cancel = tk.Button(window, text="Cancel",underline=0,command=cancel_button_func).grid(row=1,column=2)`
	`window.bind("<Alt-u>",lambda a=1,b=window.ent_username.focus_set: accelerator_helper_func(a,b))`
	`window.bind("<Alt-p>",lambda a=1,b=window.ent_password.focus_set: accelerator_helper_func(a,b))`
	`window.bind("<Alt-o>",lambda a=1,b=ok_button_func: accelerator_helper_func(a,b))`
	`window.bind("<Alt-c>",lambda a=1,b=cancel_button_func: accelerator_helper_func(a,b))`
	`window.bind("<Escape>",lambda a=1,b=cancel_button_func: accelerator_helper_func(a,b))`
	`window.ent_username.bind("<Return>",lambda a=1,b=window.ent_password.focus_set: accelerator_helper_func(a,b))`
	`window.ent_password.bind("<Return>",lambda a=1,b=ok_button_func: accelerator_helper_func(a,b))`
	`if isEdit:`
	`window.ent_username.config(state="disabled")`
	`window.ent_password.focus_set()`
	`else:`
	`window.ent_username.focus_set()`
	`return window`

	`def accelerator_helper_func(o1 = None, button_func = None, o3 = None):`
	`"""`
	`This belongs in tkstackrpms, to facilitate a window.bind("<Alt-u>",button_func) to call button_func.`
	`There is a limitation where what I wanted to call was a built-in and didn't accept more than one parameter.`
	`Parameter 1 always seems to be discarded or otherwise useless.`
	`"""`
	`print(f"DEBUG: got accelerator o1 = {o1}, button_func = {button_func}, o3 = {o3}")`
	`# o2 will be the function to call`
	`try:`
	`button_func()`
	`except Exception as e:`
	`ferror(f"ERROR: while using accelerator helper func, got error {e}")`

	`class App(tk.Frame):`
	`def __init__(self, master):`
	`super().__init__(master)`
	`self.master.title("Autologin for Lego Universe")`
	`imgicon = stk.get_scaled_icon("/mnt/public/Games/lego-universe/lego-universe-16x16.png",16,"default","","apps")`
	`self.master.tk.call("wm","iconphoto",self.master._w,imgicon)`
	`#place_popup(self.master,root,300,300)`
	`self.grid()`

	`# variables`
	`self.entries = []`
	`self.addedit_username = tk.StringVar()`
	`self.addedit_password = tk.StringVar()`

	`self.listbox = tk.Listbox(master)`
	`#listbox.insert(0,"hello world")`
	`#listbox.insert(0,"charlie")`
	`self.listbox.grid(column=0,row=0,columnspan=4,rowspan=6)`
	`self.listbox.bind('<Double-1>', self.func_login)`
	`tk.Button(self.master,text="Login",underline=0,command=self.func_login).grid(column=0,row=7)`
	`tk.Button(self.master,text="Add",underline=0,command=self.func_add).grid(column=1,row=7)`
	`tk.Button(self.master,text="Edit",underline=0,command=self.func_edit).grid(column=2,row=7)`
	`tk.Button(self.master,text="Remove",underline=0,command=self.func_remove).grid(column=3,row=7)`
	`tk.Button(self.master,text="About",underline=1,command=self.func_about).grid(column=0,row=8)`
	`self.master.bind("<Alt-l>",self.func_login)`
	`self.master.bind("<Alt-a>",self.func_add)`
	`self.master.bind("<Alt-e>",self.func_edit)`
	`self.master.bind("<Alt-r>",self.func_remove)`
	`self.master.bind("<Alt-b>",self.func_about)`
	`# initial load`
	`self.refresh_form()`
	`self.listbox.select_set(0)`

	`# functions`
	`def func_about(self, o1 = None):`
	`""" Display about dialog. """`
	`tk.messagebox.Message(title="About",message=ABOUT_TEXT,icon="info").show()`

	`def func_login(self, o1 = None):`
	`""" Get currently-selected entry in listbox, and enter that info to autologin-lego-universe.sh """`
	`print(f"DEBUG: login stub, got o1 {o1}")`
	`entry = self.get_selected_user()`
	`command = f""". /mnt/public/Games/lego-universe/autologin-lego-universe.sh ; USERNAME="{entry['username']}" PASSWORD="{entry['password']}" autologin_lego_universe"""`
	`print(f"Running command {command}")`
	`self.master.wm_state("iconic")`
	`os.system(command)`
	`sys.exit(0)`

	`def func_add(self, o1 = None):`
	`""" Ask for a new login to save to list. """`
	`print(f"DEBUG: stub func_add, got o1 {o1}")`
	`# try closing any open add/edit window`
	`self.close_addwindow()`
	`self.addedit_username.set("")`
	`self.addedit_password.set("")`
	`self.addwindow = AddEditWindow("Add entry",self.addedit_username, self.addedit_password, self.update_entry, self.close_addwindow, False)`

	`def func_edit(self, o1 = None):`
	`""" Ask for a new login to save to list. """`
	`print(f"DEBUG: stub func_edit, got o1 {o1}")`
	`print(f"DEBUG: need to get currently selected entry")`
	`# try closing any open add/edit window`
	`self.close_addwindow()`
	`entry = self.get_selected_user()`
	`if entry["username"] is None or entry["username"] == "None":`
	`return False`
	`self.addedit_username.set(entry["username"])`
	`self.addedit_password.set(entry["password"])`
	`self.addwindow = AddEditWindow("Edit entry",self.addedit_username, self.addedit_password, self.update_entry, self.close_addwindow, True)`

	`def get_selected_user(self):`
	`""" Return the dict of the currently-selected user, else return empty dict """`
	`output = {}`
	`# a single-selection listbox`
	`username = None`
	`password = None`
	`try:`
	`username = self.listbox.get(self.listbox.curselection())`
	`try:`
	`password = [i["password"] for i in self.entries if i["username"] == username][0]`
	`except Exception as e:`
	`print(f"FAILURE when looking for {username} in entries, got {e}")`
	`except tkinter.TclError as e:`
	`# no entry selected`
	`pass`
	`return {"username":username,"password":password}`

	`def close_addwindow(self, o1 = None):`
	`try:`
	`self.addwindow.destroy()`
	`except Exception as e:`
	`ferror(f"DEBUG: when trying to hide add/edit window, got {e}")`

	`def func_remove(self, o1 = None):`
	`""" Ask for a new login to save to list. """`
	`print(f"DEBUG: stub func_remove, got o1 {o1}")`
	`entry = self.get_selected_user()`
	`print(f"DEBUG: got entry {entry}")`
	`try:`
	`u = entry["username"]`
	`if u:`
	`try:`
	`self.entries.remove(entry)`
	`except ValueError as e:`
	`# the dict item was not in the list`
	`ferror(f"Probably just not in the list, but got error {e}. This is probably not a big deal.")`
	`pass`
	`except Exception as e:`
	`ferror(f"When trying to remove, got error {e}")`
	`self.save_config()`

	`def refresh_form(self):`
	`""" Load all data """`
	`self.entries = self.load_config()`
	`self.listbox.delete(0,tk.END)`
	`x = 0`
	`print(f"DEBUG: refreshing form, from entries {self.entries}")`
	`for e in self.entries:`
	`print(f"Looping over {e}")`
	`self.listbox.insert(x, e["username"])`
	`x = x + 1`

	`def load_config(self):`
	`""" Read ~/.config/autologin-lego-universe-menu.conf and get all username/pw listed there """`
	`print(f"DEBUG: loading config")`
	`try:`
	`with open(CONF_FILE,"r") as o:`
	`entries = json.load(o)`
	`except FileNotFoundError:`
	`print(f"DEBUG: need to generate new config file")`
	`with open(CONF_FILE,"a") as o:`
	`o.write("[]")`
	`entries = []`
	`#print(f"DEBUG, got entries in {type(entries)} below:")`
	`#print(entries)`
	`return entries`

	`def update_entry(self, o1 = None):`
	`""" Take add/edit window information and find the corresponding entry and update it, or else add a new one. """`
	`#print(f"DEBUG: will look for entry {self.addedit_username.get()}, and assign pw {self.addedit_password.get()}")`
	`new_u = self.addedit_username.get()`
	`new_p = self.addedit_password.get()`
	`updated = False`
	`for e in self.entries:`
	`if e["username"] == new_u:`
	`print(f"DEBUG: found entry {e}, updating pw for it.")`
	`e["password"] = new_p`
	`updated = True`
	`break`
	`if not updated:`
	`print(f"DEBUG: adding new entry, u={new_u},p={new_p}")`
	`self.entries.append(`
	`{`
	`"username": new_u,`
	`"password": new_p,`
	`}`
	`)`
	`self.save_config()`

	`def save_config(self, o1 = None):`
	`""" Save config, including the latest entry from add/edit window """`
	`self.close_addwindow()`
	`print(f"DEBUG: please save entries. Currently:")`
	`print(self.entries)`
	`#print(f"And also {self.addedit_username.get()}, {self.addedit_password.get()}")`
	`with open(CONF_FILE,"w") as o:`
	`o.write(json.dumps(self.entries))`
	`self.refresh_form()`

	`# main`
	`if "__main__" == __name__:`
	`root = tk.Tk()`
	`# naive, because it combines all monitors into one giant display for calculating.`
	`# FUTUREIMPROVMENT: get placement working`
	`root.eval('tk::PlaceWindow . center')`
	`alu = App(root)`
	`# Interesting, but not correct. It always chooses monitor 0 but the window would popup on monitor 1 if we do nothing special about geometry`
	`#print(f"DEBUG: screen width is {root.winfo_screenwidth()}")`
	`#print(f"DEBUG: screen height is {root.winfo_screenheight()}")`
	`#place_popup(alu.master,root,300,300)`
	`alu.mainloop()`

The idea with this program is to make it easy to choose between credentials. That's about it.

Screenshot of Menu for Autologin for Lego Universe, which also shows the Add Entry window

Convert PKCS7 to PEM in shell, python, powershell, and go

bgstack15 — Thu, 23 Nov 2023 13:31:41 GMT

I wrote these functions to aid myself when working with some know PKCS7 blocks from which I wanted to extract the certificates.

Powershell

Function Convert-Pkcs7-To-Pem {
   <#
      Convert Pkcs7 format to list of base64 PEM blocks like `openssl pkcs7 -print_certs`. If importing from Get-Contents -Path file, be sure to do a -join "`n" as well.
      Reference: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/verify-pkcs7.html
   #>
   [CmdletBinding(SupportsShouldProcess)]
   Param(
      [Parameter(Mandatory=$True)]$inPkcs7
   )
   Process {
      Try {
         $inPkcs7 = Convert-FileContents-To-String -Verbose:$false -inItem $inPkcs7 -joiningElement "`n"
         Add-Type -AssemblyName System.Security
         $newPkcs7b64 = [Convert]::FromBase64String($inPkcs7.Replace("-----BEGIN CERTIFICATE-----","").Replace("-----END CERTIFICATE-----",""))
         $newCerts = [Security.Cryptography.Pkcs.SignedCms]::new()
         $newCerts.decode($newPkcs7b64)
         # output resembles the `openssl pkcs7 -print_certs`
         $newCerts.Certificates | ForEach { "subject=$($_.Subject)`nissuer=$($_.Issuer)`n$($_.ExportCertificatePem())" }
      }
      Catch {
          $_
      }
   }
}
Function Convert-FileContents-To-String {
   <#
      This safely converts a Get-Contents -Path (of type Object[] basetype System.Array) to string, and passes through a string.
   #>
   [CmdletBinding(SupportsShouldProcess)]
   Param(
      [Parameter(Mandatory=$True)]$inItem,
      [Parameter(Mandatory=$False)][string]$itemName = "input",
      [Parameter(Mandatory=$False)][string]$joiningElement = "\n"
   )
   Process {
      $outItem = $inItem
      $inItemType = $inItem.GetType().Name
      Switch ($inItemType) {
         "Object[]" {
             Write-Verbose "Fixing line endings of $($itemName) with -Join `"$($joiningElement)`"."
             $outItem = $inItem -join $joiningElement
         }
         "String" {
             Write-Verbose "$($itemName) is already a string."
         }
         default {
             Write-Warning "This `$inItem.GetType().Name is not configured: $inItemType"
         }
      }
      $outItem
   }
}

Shell

This is the canonical output and the basis for the generated output of the other functions here.

printf '%s' "${pkcs7}" | openssl pkcs7 -print_certs

Python

import cryptography
from cryptography.hazmat.primitives.serialization import pkcs7
from cryptography.hazmat.primitives import serialization

def ConvertPkcs7ToPem(newPkcs7):
   newPem = ""
   newCerts = pkcs7.load_pem_pkcs7_certificates(str.encode(newPkcs7))
   for eachCert in newCerts:
      newPem += eachCert.subject.rfc4514_string() + "\n"
      newPem += eachCert.issuer.rfc4514_string() + "\n"
      newPem += eachCert.public_bytes(serialization.Encoding.PEM).decode()
   return newPem

Go

The golang one took me the longest because I barely know what I'm doing with Go and the nuances of x509 versus pem. I know this code heavily depends on knowing that my input is only ever going to contain CERTIFICATE blocks. I don't know how one would prove which type of PEM block the bytes are, if you are dealing with unspecified input.

import (
   "encoding/pem"
   "fmt"
   "go.mozilla.org/pkcs7" // run `go get go.mozilla.org/pkcs7`
)

func ConvertPkcs7ToPem(inPkcs7 string) (string, error) {
   // Assume the string already has newlines handled correctly, for now
   // We know the entire possible contents of our pkcs7 is just certificates (and not private keys or a mix of various things)
   // Reference: make PEM block myself https://stackoverflow.com/questions/56074289/how-to-get-a-string-out-of-x509-certificate-public-key-in-go
   var outString string = "";
   pemAll, _ := pem.Decode([]byte(inPkcs7))
   p7new, err := pkcs7.Parse(pemAll.Bytes)
   if err != nil {
      return "FATAL during pkcs7.Parse", err
   }
   for _, x := range p7new.Certificates {
      allBlock := pem.Block{
         Type: "CERTIFICATE",
         Bytes: x.Raw,
      }
      allBlockPem := string(pem.EncodeToMemory(&allBlock))
      outString += fmt.Sprintf("subject=%s\n",x.Subject)
      outString += fmt.Sprintf("issuer=%s\n",x.Issuer)
      outString += fmt.Sprintf("%s\n",allBlockPem)
   }
   return outString, nil
}

Keyboard LEDs trayicons in C

bgstack15 — Sun, 16 Oct 2022 13:01:19 GMT

I previously wrote a small tool for myself named keyboard-leds-trayicons, which wraps around mktrayicon to provide system tray icons that indicate the current status of Capslock and Numlock.

Well, I decided to learn some C programming and rewrite my cruddy shell scripts with their silly extra sleep 0.75 invocations. I incorporated the entirety of mktrayicon.c, and wrote new logic.

I started piecemeal: at first just adding basic fifo controls to the child processes. Then I got fancy and added Unix domain sockets. This has been a labor of love, and now it is ready to be shared. You can see the almost-product-worthy keyboard-leds-trayicons.c now. I enjoyed adding getopt and libinih support. C is such a good way to write small programs like this. I even learned how to use libxdo (which powers xdotool) so you can click the tray icons to toggle Capslock and Numlock!

Alert on new forum topics to Discord

bgstack15 — Mon, 17 Jan 2022 13:49:40 GMT

It came to my attention that my AoE2 clan mates and I don't frequent the Age of Empires forums. And it is there that the announcements for voting for the ranked map rotations occur. I decided to remedy our lack of awareness of this situation.

So, I searched on how to get notifications on a Discourse forum, which led me to a discussion on meta.discours.org. Somebody links to a python project that searches a Discourse forum and caches the results, so it can compare over time, and send notifications only on new topics, to a Mac OS notification center. This project works so great that it really only needed the Discord webhook, with no other modifications!

I secured a webhook for my clan's Discord "server" (so-called, because it's really just a namespace for us, not a dedicated VM or instance or anything) and added a few lines of Discord logic to that project, named sniffa.

I set up my sniffa input file, ~/.sniffa/watches-aoe2.ini with this contents:

[sniffa.domain]
url = https://forums.ageofempires.com
webhook = 'https://discord.com/api/webhooks/123498237429749274924/justanexamplewebhook123458987s87'
discord_user = AoE2 forum bot

[VOTE NOW ranked rotation #age-of-empires-ii:aoe2-de in:title]
ids = 666250,280747,280748,666257,651927

And I set up an unprivileged local user and installed pip package discord. And I placed in crontab:

*/30  *  *  *  *  bot   /home/bot/sniffa/sniffa.py aoe2 1>/dev/null 2>&1

How it works

The way sniffa works is it uses the ini section headings [VOTE NOW...] as the search expression, and it uses the modern web abilities to fetch results of mimetype application/json, from the native Discourse search function! It's really clever. And then, it gets better. It caches the results back to the ini file, so that it only alerts on new results.

I crafted my search query by visiting the forum and adjusting my search parameters and options until it was exactly what I want. Additional searches can be added by just adding a new [search query] heading!