Site Map - skip to main content

Hacker Public Radio

Your ideas, projects, opinions - podcasted.

New episodes Monday through Friday.



Welcome to HPR the Community Podcast

We started producing shows as Today with a Techie on 2005-09-19, 16 years, 0 months, 12 days ago. Our shows are produced by listeners like you and can be on any topic that "are of interest to Hackers". If you listen to HPR then please consider contributing one show a year. If you record your show now it could be released in 22 days.

Meet the team

Please help out tagging older shows !


Latest Shows


hpr3431 :: Living in the Terminal

BlacKernel shows you some programs you'll need for living life without X org

Hosted by BlacKernel on 2021-09-27 is flagged as Explicit and released under a CC-BY-SA license.
Tags: cli, terminal, nox, linux, technology, tty.
Listen in ogg, spx, or mp3 format. Series: Lightweight Apps | Comments (0)

Talking Points

Rational

  • Sometimes, X.org just doesn't want to work
  • Esspecially if you are a dumb n00b running Arch
  • The terminal will always be there for you.

Applications:

My .bashrc:

  • Environment Variables:
export EDITOR=nvim
export PAGER=most
export BROWSER=lynx

export XDG_DATA_HOME="$HOME/.local/share"
export XDG_CONFIG_HOME="$HOME/.config"

PS1: user@hostname:~ (git_branch) $

if [[ $EUID == 0 ]]; then
    export PS1="\[e[1;31m\]\u\[\e[m\]@\[\e[0;32m\]\h\[\e[m\]:\w\$(__git_ps1) # "
else
    export PS1="\[e[1;34m\]\u\[\e[m\]@\[\e[0;32m\]\h\[\e[m\]:\w\$(__git_ps1) $ "
fi
  • Aliases:
    • alias vim=nvim
    • alias play=mpv

Productivity ("Window Manager"): tmux

  • Provides an easy way of splitting a tty into various panes
  • Get multiple workspaces for free with CTL+ALT+F{1,2,3,4,5,6,7}
  • All of the tiling window manager, none of the X-it
  • Can set up if [ -t 0 ] && [[ -z $TMUX ]] && [[ $- = *i* ]]; then exec tmux; fi in .bashrc in order to have tmux start/stop with your terminal sessiion.

Music: cmus

  • Easy library and playlist management
  • Dead simple to use (with cmus-tutorial)
    • y to yank songs onto a playlist
    • SPA to select a playlist
    • RET to play a song/playlist
    • TAB to switch between panes

Pictures: fim

  • Requires user be in the video group for permission to use the Linux framebuffer

Radio/Video/single audio files: mpv

  • Can display video in terminal (badly with libcaca)
  • Can actually display video in linux framebuffer (with drm)
  • Can handle all of your somafm files/web-video links
  • Requires youtube-dl for video

Podcasts/RSS: newsboat/podboat

  • Orginizes all of your podcasts and RSS feeds into an easy-to-use ncurses interface
  • Can be set up with player "mpv --save-position-on-quit" to save positions on podcasts
  • Very convinent for articles, less so for podcasts
  • Really needs better integration with something like cmus

Runner Up: podfox

  • Can be configured with JSON
  • Has better directory structure than podboat, imo
  • Tree based structure vs shove everything in ~ by default

Text Editing/Word Processing: neovim/GitX Flavored Markdown/pandoc

  • Clean modal editing
  • Can export to whatever with pandoc
  • Probably not as good as OrgMode if emacs wasn't the HFS+ of text editors

Audio Recording/Post-Processing: ffmpeg

  • One alias and three scripts in my .bashrc
    • record: alias record="ffmpeg -f alsa -channels 1 -i hw:1"
    • atrim, top-tail, and anorm: Allows me to quickly spin up a recording and run post processing
function atrim() {
    if [ $1 ]; then
        local in="$1"
    else
        local in="-"
    fi

    if [ $2 ]; then
        local out="$2"
    else
        local out="-f nut -"
    fi

    if [[ $# > 2 ]]; then
        echo "atrim: requires 2 or fewer arguments"
        return 1
    fi

    if [ $2 ]; then echo "atrim: silencing $in and saving to $out..."; fi
    ffmpeg -i $in -af silenceremove=start_periods=1:stop_periods=-1:start_threshold=-50dB:stop_threshold=-50dB:stop_duration=0.75 $out \
        2>/dev/null \
        #1>/dev/null
    if [ $2 ]; then echo "atrim: done"; fi
}
function top-tail() {
    local top="$HOME/project/hpr-notes/template/intro-music-slick0-cc0.flac"
    local tail="$HOME/project/hpr-notes/template/outro-mixed-slick0-manon_fallon-cc0.flac"

    if [ $1 ]; then
        local in="$1"
    else
        local in="-"
    fi

    if [ $2 ]; then
        local out="$2"
    else
        local out="-f nut -"
    fi

    if [[ $# > 2 ]]; then
        echo "hpr-top-tail: requres 2 or fewer arguments"
        return 1
    fi

    if [ $2 ]; then echo "hpr-top-tail: Topping $in with $top and tailing with $tail..."; fi
    ffmpeg -i "$top" -i $in -i "$tail" -vn -filter_complex "
    [0][1]acrossfade=d=1:c1=tri:c2=tri[a01];
    [a01][2]acrossfade=d=1:c1=tri:c2=tri" \
    $out \
        2> /dev/null \
        #1> /dev/null
    if [ $2 ]; then echo "hpr-top-tail: done"; fi
}
function anorm() {
    if [ $1 ]; then
        local in="$1"
    else
        local in="-"
    fi

    if [ $2 ]; then
        local out="$2"
    else
        local out="-f nut -"
    fi

    if [[ $# > 2 ]]; then
        echo "anorm: requires 2 or fewer arguments"
        return 1
    fi

    if [ $2 ]; then echo "anorm: normalizing audio $in and saving to $out..."; fi
    ffmpeg -i $in $(ffmpeg-lh $in) $out \
        #2> /dev/null \
        1> /dev/null
    if [ $2 ]; then echo "anorm: done"; fi

}

Web Browsing: lynx

  • Fast and easy text based web browsing
  • Can leverage Web 4.0 technologies like Gopher!!
  • Some sites break pretty bad...

Email: mutt*

  • I didn't really use email very much when I was living on the terminal and now, since I use protonmail, I don't really have an easy way not to use the webmail.

  • Trying to find a fix to this. Let me know your thoughts!

  • This is the mail client I've heard the most good things about that isn't built into a text editor I can't use


Show Notes

Resources:


Contact Me

hpr3430 :: Booting

We look in detail at how early PCs booted.


Hosted by Ahuka on 2021-09-24 is flagged as Clean and released under a CC-BY-SA license.
Tags: DOS, early PC computing, boot process.
Listen in ogg, spx, or mp3 format. Series: DOS | Comments (2)

The boot process is a very particular system for taking a dead hunk of metal and silicon and turning it into an active computer. It is kind of remarkable, and in the DOS environment you really needed to know how it worked.


hpr3429 :: Linux Inlaws S01E39: Ubuntu and the Community

All about your favourite Debian spin and IBM mainframes

Hosted by monochromec on 2021-09-23 is flagged as Explicit and released under a CC-BY-SA license.
Tags: Debian, Ubuntu, IBM, mainframes, snaps, Canonical.
Listen in ogg, spx, or mp3 format. Series: Linux Inlaws | Comments (1)

In this episode, our two hosts host Rhys Davies, a developer advocate from Canonical. So all beans will be spilled on one of the most popular Linux distros out there. Like its past, present and future. Never mind how Canonical makes its moolah and where this goes... Plus an interesting infomercial on old big iron (IBM, if you're listening: the mail address is sponsor@linuxinlaws.eu).

Links:


hpr3428 :: Bad disk rescue

Bad disk rescue - tragedy or happy ending?

Hosted by Andrew Conway on 2021-09-22 is flagged as Clean and released under a CC-BY-SA license.
Tags: linux,disk,windows,virtualbox.
Listen in ogg, spx, or mp3 format. Comments (0)

Here I tell the tale of a bad disk rescue. Is the rescue bad or just the disk? Well the disk is most certainly bad but please listen and tell me if the rescue was good or bad or could have been done better.

Guest stars in this show include:


hpr3427 :: Ranger for the Win!

In this episode, I go over some typical use cases for the Ranger file manager


Hosted by b-yeezi on 2021-09-21 is flagged as Clean and released under a CC-BY-SA license.
Tags: ranger,file manager,linux.
Listen in ogg, spx, or mp3 format. Comments (1)

Programs referenced in this episode

  • ranger
  • caca-utils
  • poppler-utils
  • atool
  • highlight
  • trash-cli
  • xlsx2csv
  • docs2txt
  • catdoc (for doc2txt and xls2csv)
  • ods2tsv

hpr3426 :: Rust 101: Episode 0 - What in Tarnishing?

BlacKernel teaches you what rust is and how it is different from Python or C.

Hosted by BlacKernel on 2021-09-20 is flagged as Clean and released under a CC-BY-SA license.
Tags: rust, programming, raii, python, c.
Listen in ogg, spx, or mp3 format. Series: Programming 101 | Comments (2)

Talking Points

  • What is Rust?
    • " Garbage Collection " - Resource Acquisition Is Initialization (RAII)
    • Strict Typing with Type Inference
    • Reference pointers
    • Immutable by default
    • Unsafe Mode
  • Why use Rust over Python?
    • Speed
    • Compiled
      1. Help from compiler
      2. Smaller binary size
      3. Useful in high throughput/embedded applications
    • Logically consistent
  • Why use Rust over C?
    • Safe by default
    • Easier to read
    • Forces you to write good code
    • Arrays without stupidity++ and built in vectors
    • Option<T> and Result<T> or a match {} made in heaven

Show Notes

Strict Typing

fn main() {

    // Type declared with var: <T> syntax
    let penguin_one: &str = "gentoo";
    
    // Type &str is inherited from "gentoo"
    let penguin_two = "gentoo";
    
    // Will not panic if they are the same
    assert_eq!(penguin_one, penguin_two);
}

Reference Pointers

Wrong Way:

fn print_u8_vector(vec: Vec<u8>) {
    println!("{:?}", vec);
}

fn main() {
    let penguin_ages: Vec<u8> = vec!(2, 4, 6);
    print_u8_vector(penguin_ages);
    
    // This line will throw an error
    println!("{}", penguin_ages[0]);
}

Correct Way:

fn print_u8_vector(vec: &Vec<u8>) {
    println!("{:?}", vec);
}

fn main() {
    let penguin_ages: Vec<u8> = vec!(2, 4, 6);
    print_u8_vector(&penguin_ages);
    
    // This line will print '2'
    println!("{}", penguin_ages[0]);
}

Immutable By Default

Wrong Way:

fn main() {
    let my_num = 2;
    
    // This line will throw an error
    my_num = my_num + 1;
    println!("{}", my_num);
}

Correct Way:

fn main() {
    let mut my_num = 2;
    my_num = my_num + 1;
    
    // This line will print '3'
    println!("{}", my_num);
}

Unsafe Code

Hello World Program in C in Rust:

extern "C" {
    fn printf(input: &str);
}

fn main() {
    unsafe {
        printf("Hello, World!");
    }
}

Contact Me

Email: izzyleibowitz at pm dot me

Mastodon: at blackernel at nixnet dot social


hpr3425 :: Hacking Stories with Reacted: part 4

I talk about some old old old pentesting stories from days old!

Hosted by operat0r on 2021-09-17 is flagged as Clean and released under a CC-BY-SA license.
Tags: hacking,pentesting,red team,hacking stories.
Listen in ogg, spx, or mp3 format. Comments (0)

I talk about some old old old pentesting stories from days old!


hpr3424 :: Infosec Podcasts Part 6 - Infosec Leadership

Presenting my favorite information security leadership podcasts

Hosted by Trey on 2021-09-16 is flagged as Clean and released under a CC-BY-SA license.
Tags: infosec, podcasts, security, leadership.
Listen in ogg, spx, or mp3 format. Series: Podcast recommendations | Comments (0)

Inoffensive in every region of the world.

Thank you to everyone who has listened to my previous episodes. This is the final episode in the Infosec Podcasts series.

I listen to many, MANY podcasts. The vast majority of these are related to information security.

Because there are so many podcasts to list, I have broken them down into 6 different episodes based on topics:

  • Part 1 - News & Current Events - Episode 3324
  • Part 2 - General Information Security - Episode 3334
  • Part 3 - Career & Personal Development - Episode 3344
  • Part 4 - Social Engineering - Episode 3368
  • Part 5 - Episode 3387
    • Hacks & Attacks
    • Technical Information & Learning
    • Infosec Community / Social / History
    • Part 6 - Infosec Leadership

Preamble

Term: CISO

  • Pronounced SEE-so or SAI-so
  • Chief Information Security Officer
  • Sounds like executive leadership position, similar to Chief Executive Officer (CEO), Chief Financial Officer (CFO), etc but this is often not the case

Security leadership is changing

Old way:

  • Experienced technologists (Usually old white guys) worked way up ranks
  • Usually reported through IT (CIO/CTO)
  • Department of "No" - Block everything bad
  • Slows down business

New way:

  • Experienced business professionals with leadership skills and security understanding
  • Can report through:
    • IT (CIO/CTO)
    • Legal (For compliance reasons)
    • Finance (CFO) for governance or compliance reasons
    • Financial impacts of attacks
    • Direct costs
    • Fines
    • CEO - Seat at the table with other C-level execs
    • Direct to board
  • Empowers the business to succeed in a secure way
  • Can still slow down the business, but only when needed
    • Brakes on a race car

Infosec Leadership Podcasts

  • CISO Tradecraft - G Mark Hardy (Weekly)
  • CISO Vendor Relationship Podcast - David Spark & Guests (Weekly)
  • CISO Talks (Weekly)
  • CISO Talk - James Azar (Weekly)
  • The Cyber Ranch Podcast - Allan Alford & Hacker Valley Studios (Weekly)
  • CISO's Secrets - Currently hosted by Grant Asplund and sponsored by Checkpoint
    • Interviews with security leaders across a wide range of industries
    • Addresses real issues facing security professionals and businesses
    • https://cp.buzzsprout.com/
  • CISO Stories - Hosted by Todd Fitzgerald and Sam Curry and part of the Security Weekly family of podcasts
  • The New CISO - Hosted by Exabeam's Chief Security Strategist, Steve Moore and Sponsored by Exabeam

That wraps up this series. I welcome any feedback you might have in the comments section for this episode on the HPR site.

Thank you very much for listening.


hpr3423 :: "upg.sh" my "dump.txt" to "note.md"

I upgraded my scripts.


Hosted by Some Guy On The Internet on 2021-09-15 is flagged as Clean and released under a CC-BY-SA license.
Tags: Bash Scripting, sed, awk, xargs, markdown, notes.
Listen in ogg, spx, or mp3 format. Comments (1)

upg.sh my dump.txt to note.md

SYNOPSIS: upg.sh

  • Upgrade your system and store stdout into a markdown file.
#!/bin/bash
# upg.sh

FILENAME=sys-upgrade$(date +%m-%d-%Y).md
DIRECTORY="${HOME}/Documents/"

# step 1: formatting.
echo -e "# **System Upgrade:** $(date)\n" \
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "**Command:** \`sudo apt-get update; sudo apt-get upgrade --yes\`\n" \
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "**Command Breakdown:**" \
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "- \`sudo\`, Admin Privilages." \
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "- \`apt-get\`, Package Manager." \
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "- \`update;\`, Package Manager's task; update the system software repositories." \
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "- \`sudo apt-get upgrade\`, Perform system upgrade with updated repositories." \
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "- \`--yes\`, Answers yes to the prompt." \
    | tee -a ${DIRECTORY}${FILENAME}

# step 2: run commands with formatting.
echo -e "\n**Command std-output:**\n" \
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "\`\`\`" \
    | tee -a ${DIRECTORY}${FILENAME}
    echo $(date) \
    | tee -a ${DIRECTORY}${FILENAME}

sudo apt-get update \
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "\n# System update completed.\n" \
    | tee -a ${DIRECTORY}${FILENAME}

sudo apt-get upgrade --yes \
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "\n# System upgrade completed.\n" \
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "\`\`\`\n" \
    | tee -a ${DIRECTORY}${FILENAME}

# step 3: additional details with more formatting.
echo -e "**Upgraded Package Details:**\n" \
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "\`\`\`" \
    | tee -a ${DIRECTORY}${FILENAME}

PKGLIST=$(sed -n "/The following packages will be upgraded:/,/^.. upgraded/p" ${FILENAME} \
    | sed '1d;$d' | xargs -n 1 | sed '/:i386$/d') \

PKGCACHE=$(echo -e "${PKGLIST}\n" \
    | xargs -n1 -I _ apt-cache search _)
echo "${PKGCACHE}" > ${DIRECTORY}delete.txt

echo "${PKGLIST}" \
    | xargs -n 1 -I _ echo "sed -n '/^_ /p'" "${DIRECTORY}delete.txt" \
    | bash | tee -a ${DIRECTORY}${FILENAME};

echo -e "\`\`\`" \
    | tee -a ${DIRECTORY}${FILENAME}

rm -v ${DIRECTORY}delete.txt;
PKGLIST=
PKGCACHE=

# step 4: place EOF (end of file).
    sed -i '/EOF/d' ${DIRECTORY}${FILENAME}
echo "EOF" >> ${DIRECTORY}${FILENAME}
#EOF

Script breakdown: upg.sh

  • First, we declare bash as our shell with #!/bin/bash. We could also use #!/bin/sh for a more portable script.

  • I like to paste the name of the script we're working on into the script itself # upg.sh.

  • Setup a couple of variables to shorten the syntax.

FILENAME=sys-upgrade$(date +%m-%d-%Y).md
DIRECTORY="${HOME}/Documents/"
  • # step 1: formatting.
    • Build labels and a short breakdown of the update/upgrade commands used.
echo -e "# **System Upgrade:** $(date)\n" \                                                    <-- formatting: label with date.
    | tee -a ${DIRECTORY}${FILENAME}                                                           <-- path/to/file
echo -e "**Command:** \`sudo apt-get update; sudo apt-get upgrade --yes\`\n" \                 <-- formatting: command label.
    | tee -a ${DIRECTORY}${FILENAME}                                                           <-- path/to/file
echo -e "**Command Breakdown:**" \                                                             <-- formatting: label.
    | tee -a ${DIRECTORY}${FILENAME}                                                           <-- path/to/file
echo -e "- \`sudo\`, Admin Privilages." \                                                      <-- formatting: label.
    | tee -a ${DIRECTORY}${FILENAME}                                                           <-- path/to/file
echo -e "- \`apt-get\`, Package Manager." \                                                    <-- formatting: label.
    | tee -a ${DIRECTORY}${FILENAME}                                                           <-- path/to/file
echo -e "- \`update;\`, Package Manager's task; update the system software repositories." \    <-- formatting: label.
    | tee -a ${DIRECTORY}${FILENAME}                                                           <-- path/to/file
echo -e "- \`sudo apt-get upgrade\`, Perform system upgrade with updated repositories." \      <-- formatting: label.
    | tee -a ${DIRECTORY}${FILENAME}                                                           <-- path/to/file
echo -e "- \`--yes\`, Answers yes to the prompt." \                                            <-- formatting: label.
    | tee -a ${DIRECTORY}${FILENAME}                                                           <-- path/to/file
  • # step 2: run commands with formatting.,
    • Setup labels and an area for the stdout to be store with markdown formatting.
    • We place the time and date into the stdout area then run the commands.
echo -e "\n**Command std-output:**\n" \                                                        <-- formatting: label.
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "\`\`\`" \                                                                             <-- formatting: markdown.
    | tee -a ${DIRECTORY}${FILENAME}
    echo $(date) \                                                                             <-- command: date.
    | tee -a ${DIRECTORY}${FILENAME}

sudo apt-get update \                                                                          <-- command: update.
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "\n# System update completed.\n" \                                                     <-- formatting: label.
    | tee -a ${DIRECTORY}${FILENAME}

sudo apt-get upgrade --yes \                                                                   <-- command: upgrade with "--yes" option.
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "\n# System upgrade completed.\n" \                                                    <-- formatting: label.
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "\`\`\`\n" \                                                                           <-- formatting: markdown.
    | tee -a ${DIRECTORY}${FILENAME}
  • # step 3: additional details with more formatting.,
    • List the packages that were upgraded with details from system cache.
echo -e "**Upgraded Package Details:**\n" \                                                    <-- formatting: label.
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "\`\`\`" \                                                                             <-- formatting: markdown.
    | tee -a ${DIRECTORY}${FILENAME}

PKGLIST=$(sed -n "/The following packages will be upgraded:/,/^.. upgraded/p" ${DIRECTORY}${FILENAME} \  <--| variable with list of packages within it.
    | sed '1d;$d' | xargs -n 1 | sed '/:i386$/d') \                                            <--| sed: filter the first and last lines then remove the :i386 duplicate packages.

PKGCACHE=$(echo -e "${PKGLIST}\n" \                                                            <--| variable with massive apt-cache search results.
    | xargs -n1 -I _ apt-cache search _)                                                       <--| xargs runs the PKGLIST (the _ is the value of PKGLIST) into the apt-cache search.
echo "${PKGCACHE}" > ${DIRECTORY}delete.txt                                                    <--| I had to put the PKGCACHE in a file. I couldn't get sed to filter a variable (yet).

echo "${PKGLIST}" \                                                                            <--| use that PKGLIST to create a few sed commands to filter the file called "delete.txt".
    | xargs -n 1 -I _ echo "sed -n '/^_ /p'" "${DIRECTORY}delete.txt" \                        ^--| xargs is used to create the sed commands.
    | bash | tee -a ${DIRECTORY}${FILENAME};                                                   <--| run the sed commands through bash then store them.

echo -e "\`\`\`" \
    | tee -a ${DIRECTORY}${FILENAME}

rm -v ${DIRECTORY}delete.txt;                                                                  <--| use rm to delete the file called "delete.txt" it has the apt-cache search results in it.
PKGLIST=                                                                                       <--| empty the variable. why? why not!
PKGCACHE=                                                                                      <--| empty the variable. why? why not!
  • # step 4: place EOF (end of file).,
    • Add EOF (END OF FILE) to the end of the file. If one is already there, -
    • it's removed then replaced in the correct position.
    sed -i '/EOF/d' ${DIRECTORY}${FILENAME}                                                    <--| search for EOF then remove it. we don't want multiple EOF if we run the script multiple times in the same day.
echo "EOF" >> ${DIRECTORY}${FILENAME}                                                          ^--| adds the EOF (End Of File) at the end of the file.  I read it was a nice thing to do.
#EOF                                                                                           <--| Yep. it's there.


SYNOPSIS: note.sh "command" "filename"

  • example: note.sh "ls -lhA" "basic-list"
  • make markdown notes of your commands.
#!/bin/bash
# note.sh "command" "filename" no extentions.

# variables
FILENAME=$2$(date +%m-%d-%Y).md
DIRECTORY="${HOME}/Documents/"

# step 1: create file with formatting.
echo -e "# **Command:** \` $1 \`\n" \
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "**Command Breakdown:**" \
    | tee -a ${DIRECTORY}${FILENAME}
echo "$1" | tr " " '\n' \
    | awk '{ print "- `" $0 "`, info." }' \
    | tee -a ${DIRECTORY}${FILENAME}

# step 2: run command with more formatting.
echo -e "\n**Command std-output:**" \
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "\`\`\`\n$(date)" \
    | tee -a ${DIRECTORY}${FILENAME}

echo $1 | bash \
    | tee -a ${DIRECTORY}${FILENAME}

echo -e "\`\`\`" \
    | tee -a ${DIRECTORY}${FILENAME}

echo -ne "\n${FILENAME} has been updated $(date)."

# step 3: insert EOF (End Of File).
sed -i '/EOF/d' ${DIRECTORY}${FILENAME}
echo EOF >> ${DIRECTORY}${FILENAME}

Script breakdown: upg.sh

  • First, we declare bash as our shell with #!/bin/bash. We could also use #!/bin/sh for a more portable script.

  • I like to paste the name of the script we're working on into the script itself # upg.sh.

  • Setup a couple of variables to shorten the syntax.

FILENAME=$2$(date +%m-%d-%Y).md                                                                <--| the "$2" is the second user input (file name) from the commandline.
DIRECTORY="${HOME}/Documents/"
  • # step 1: create file with formatting.
    • Build labels for Command Name with a short breakdown of the command(s) used.
    • Note: the breakdown must be entered manually.
echo -e "# **Command:** \` $1 \`\n" \                                                          <--| the "$1" is the first user input (the command) from the commandline.
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "**Command Breakdown:**" \
    | tee -a ${DIRECTORY}${FILENAME}
echo "$1" | tr " " '\n' \                                                                      <--| This just breaks the command into parts then adds some markdown formatting for use to add -
    | awk '{ print "- `" $0 "`, info." }' \                                                    ^--| details to later. I just added the word info so you know to provide info about the command. -
    | tee -a ${DIRECTORY}${FILENAME}                                                           ^--| the formatting gets a bit crazy if you use something like: awk {' print $1 $2 $3 '} path/to/file;  each space becomes a newline with the markdown formatting.
  • # step 2: run command with more formatting.
    • Echo the Command into bash with markdown formatting for stdout.
echo -e "\n**Command std-output:**" \
    | tee -a ${DIRECTORY}${FILENAME}
echo -e "\`\`\`\n$(date)" \
    | tee -a ${DIRECTORY}${FILENAME}

echo $1 | bash \
    | tee -a ${DIRECTORY}${FILENAME}

echo -e "\`\`\`" \
    | tee -a ${DIRECTORY}${FILENAME}

echo -ne "\n${FILENAME} has been updated $(date)."
  • # step 3: insert EOF (End Of File).
    • Add EOF (END OF FILE) to the end of the file. If one is already there, -
    • it's removed then replaced in the correct position.
sed -i '/EOF/d' ${DIRECTORY}${FILENAME}
echo EOF >> ${DIRECTORY}${FILENAME}

Correspondent: Some Guy On The Internet.
Host ID: 391
E-mail: Lyunpaw.nospam@nospam.gmail.com


hpr3422 :: Update about Phones and Devices

An Update about my New Phone and second one that is coming


Hosted by JWP on 2021-09-14 is flagged as Clean and released under a CC-BY-SA license.
Tags: Android, phone, Linux, Pine64, Smart Watch.
Listen in ogg, spx, or mp3 format. Comments (0)

Small update about my new RedMi 10s and my new Monty Mint phone.


Previous five weeks

hpr3421 :: BlacKernel's Journey Into Technology: Episode 1 hosted by BlacKernel

Released: 2021-09-13. Duration: 00:16:07. Flag: Clean.
Tags: technology, childhood, stories.
Learning about Assembly and Social Engineering before I could read

hpr3420 :: Normal Layer Modes: Erase, Merge, and Split hosted by Ahuka

Released: 2021-09-10. Duration: 00:10:06. Flag: Clean. Series: GIMP.
Tags: GIMP, Layer Modes, Blending Modes.
We continue our look at the Layer Modes in GIMP

hpr3419 :: Linux Inlaws S01E38: Tiny kernels hosted by monochromec

Released: 2021-09-09. Duration: 01:02:28. Flag: Explicit. Series: Linux Inlaws.
Tags: Operating systems, kernels, Usenet wars, Linus Torvalds, Andrew Tanenbaum, Minix, trainspotting.
All you ever wanted to hear and more about micro kernels and other operating system war stories

hpr3418 :: My gEeeky Experiment - Part 2 hosted by Claudio Miranda

Released: 2021-09-08. Duration: 00:10:48. Flag: Clean.
Tags: asus,eeepc,haiku,beos,starmax,bebox,motorola,be.
Claudio talks about how he installed Haiku on an Asus Eee PC 900a received from a friend.

hpr3417 :: Ceph cluster hardware hosted by Daniel Persson

Released: 2021-09-07. Duration: 00:12:09. Flag: Clean.
Tags: ceph, cluster, hardware.
Looking into the hardware behind my ceph cluster

hpr3416 :: HPR Community News for August 2021 hosted by HPR Volunteers

Released: 2021-09-06. Duration: 01:36:05. Flag: Explicit. Series: HPR Community News.
Tags: Community News.
Ken's not available so MrX joins Dave to talk about the shows and comments in August

hpr3415 :: Hacking Stories with Reacted: part 3 hosted by operat0r

Released: 2021-09-03. Duration: 00:13:56. Flag: Explicit.
Tags: hacking,pentesting,red team,hacking stories.
I talk about some old old old pentesting stories from days old!

hpr3414 :: Critical Thinking may make You Critical of the Covid Crisis hosted by CoGo

Released: 2021-09-02. Duration: 00:10:45. Flag: Explicit.
Tags: covid, vitamin D3, masks, viruses, lawyers.
Some Science YOU can observe about covid fallacies, and some preventative medicine.

hpr3413 :: Bash snippet - using coproc with SQLite hosted by Dave Morriss

Released: 2021-09-01. Duration: 00:45:38. Flag: Explicit. Series: Bash Scripting.
Tags: Bash,coproc,subshell,coprocess,pipe,file descriptor.
Sending multiple queries to a running instance of sqlite3

hpr3412 :: Reading a license: Creative Commons Attribution ShareAlike 3.0 Unported hosted by clacke

Released: 2021-08-31. Duration: 00:34:58. Flag: Clean.
Tags: license, creative commons, recital, reading, legal.
We are using this license but we didn't publish it on HPR ... until now!

hpr3411 :: Dominion card game hosted by klaatu

Released: 2021-08-30. Duration: 00:27:53. Flag: Clean. Series: Tabletop Gaming.
Tags: card, game.
Klaatu talks about the Dominion card game

hpr3410 :: Operating Systems hosted by Ahuka

Released: 2021-08-27. Duration: 00:13:48. Flag: Clean. Series: DOS.
Tags: DOS, early PC computing, operating systems.
Here we look at what an operating system is, and how they developed historically.

hpr3409 :: Linux Inlaws S01E37: All about Hacker Public Radio hosted by monochromec

Released: 2021-08-26. Duration: 01:35:38. Flag: Explicit. Series: Linux Inlaws.
Tags: HPR, cleaning, janitoring, having a good time, Richard M. Stallman, stats.
An interview with Ken Fallon, Janitor at Hacker Public Radio

hpr3408 :: Composting hosted by Rho`n

Released: 2021-08-25. Duration: 00:05:36. Flag: Clean.
Tags: food,rubbish,landfill,gardening,compost,composting.
Inspired by episode 3157, Rho`n describes his experience of learning to compost

hpr3407 :: Software Freedom Podcast hosted by Ken Fallon

Released: 2021-08-24. Duration: 00:56:47. Flag: Clean. Series: Podcast recommendations.
Tags: FSFE,Podcast,freeculturepodcasts.
A sample episode of the Free Software Foundation Europe Podcast

hpr3406 :: A study of cards in games hosted by klaatu

Released: 2021-08-23. Duration: 00:27:13. Flag: Clean. Series: Tabletop Gaming.
Tags: card, game.
Currency, deterrent, coersion, clutter, rules

hpr3405 :: Hacking Stories with Reacted: part 2 hosted by operat0r

Released: 2021-08-20. Duration: 00:02:32. Flag: Clean.
Tags: hacking,pentesting,red team,hacking stories.
I talk about some old old old pentesting stories from days old!

hpr3404 :: Suse 15.3 Leap hosted by JWP

Released: 2021-08-19. Duration: 00:10:52. Flag: Clean.
Tags: linux, suse, leap, vnc.
A short review of Suse 15.3

hpr3403 :: Forth on microcontrollers hosted by Brian in Ohio

Released: 2021-08-18. Duration: 00:22:21. Flag: Clean.
Tags: programming, history, arduino.
A little more about forth and a couple of chapters in the novel of my life

hpr3402 :: Reading a manifesto: Declaration of Digital Autonomy hosted by clacke

Released: 2021-08-17. Duration: 00:14:37. Flag: Explicit.
Tags: manifesto, community, free software, open source, politics, philosophy, digital autonomy.
Reading and brief commentary and background on Molly DeBlanc's and Karen Sandler's techautonomy.org

hpr3401 :: Mana hacks hosted by klaatu

Released: 2021-08-16. Duration: 00:32:04. Flag: Clean. Series: Tabletop Gaming.
Tags: magic, mtg, card, tcg, mana.
Klaatu muses about mana ramping in Magic the Gathering

hpr3400 :: Normal Layer Modes: Normal, Dissolve, Color Erase hosted by Ahuka

Released: 2021-08-13. Duration: 00:12:58. Flag: Clean. Series: GIMP.
Tags: GIMP, Layer Modes, Blending Modes.
We begin a look at the Layer Modes in GIMP

hpr3399 :: Linux Inlaws S01E36: Open Source Licenses hosted by monochromec

Released: 2021-08-12. Duration: 00:56:01. Flag: Explicit. Series: Linux Inlaws.
Tags: Licensing, GNU, BSD, MIT, Taking Lives, MI6, Clarkson's Farm, Open Source Initiative.
The ultimate show on open source licenses or how to fall asleep without chemicals

hpr3398 :: Anacron hosted by klaatu

Released: 2021-08-11. Duration: 00:15:49. Flag: Clean.
Tags: cron, linux, service, automation.
Put down that crontab and get started with anacron

hpr3397 :: What is a PineTime hosted by Daniel Persson

Released: 2021-08-10. Duration: 00:09:55. Flag: Clean.
Tags: open source, watch, coding.
In this podcast I talk a little bit about the pinetime.

hpr3396 :: Card roles in Magic the Gathering hosted by klaatu

Released: 2021-08-09. Duration: 00:39:27. Flag: Clean.
Tags: magic, mtg, card, tcg.
There are over 25,000 cards in MTG. You only need 60 to play.

hpr3395 :: Hacking Stories with Reacted: part 1 hosted by operat0r

Released: 2021-08-06. Duration: 00:32:59. Flag: Explicit.
Tags: hackhacking,pentesting,red team,hacking storiesing.
I talk about some old old old pentesting stories from days old!

hpr3394 :: Be an XML star with xmlstarlet hosted by klaatu

Released: 2021-08-05. Duration: 00:26:31. Flag: Clean.
Tags: xml,data,markup,markdown.
Parse XML from the terminal

hpr3393 :: We need to talk about XML hosted by klaatu

Released: 2021-08-04. Duration: 00:31:25. Flag: Clean.
Tags: xml,data,markup,markdown.
An extensible markup language? This is too good to be true!

hpr3392 :: Structured error reporting hosted by tuturto

Released: 2021-08-03. Duration: 00:28:34. Flag: Explicit. Series: Haskell.
Tags: haskell, error reporting.
tuturto talks about how she improved build times by breaking down error reporting to smaller parts

hpr3391 :: HPR Community News for July 2021 hosted by HPR Volunteers

Released: 2021-08-02. Duration: 01:16:51. Flag: Explicit. Series: HPR Community News.
Tags: Community News.
HPR Volunteers talk about shows released and comments posted in July 2021

hpr3390 :: Intro to DOS Series hosted by Ahuka

Released: 2021-07-30. Duration: 00:13:23. Flag: Clean. Series: DOS.
Tags: DOS, early PC computing.
We begin some technological archeology to explore the old warhorse, DOS.

hpr3389 :: Tales of a Tagger hosted by Archer72

Released: 2021-07-29. Duration: 00:06:06. Flag: Clean.
Tags: tags,mplayer,Android,Termux,vim,i3 window manager.
Adventures and mishaps tagging past shows

hpr3388 :: Linux Inlaws S01E35: The Free Software Foundation Europe hosted by monochromec

Released: 2021-07-28. Duration: 01:18:15. Flag: Explicit. Series: Linux Inlaws.
Tags: FSFE, FSF, Stallman, Hackathon, Communism, Towel Day.
An interview with Matthias Kirschner, Free Software Foundation Europe

hpr3387 :: Infosec Podcasts Part 5 Grab bag hosted by Trey

Released: 2021-07-27. Duration: 00:08:03. Flag: Explicit. Series: Podcast recommendations.
Tags: infosec, podcasts, security.
Presenting my favorite podcasts related to various aspects of information security

hpr3386 :: What's for dinner? hosted by Dave Morriss

Released: 2021-07-26. Duration: 00:22:22. Flag: Explicit.
Tags: Perl,SQLite3,database,food.
Some scripts and a database for randomly choosing which meal to cook

hpr3385 :: DIY Cat feeder! hosted by operat0r

Released: 2021-07-23. Duration: 00:13:44. Flag: Clean.
Tags: cats,3d printing,hacking,arduino.
I talk about 3d printed cat feeders

hpr3384 :: Page Numbers in EPUB eBook Files hosted by Jon Kulp

Released: 2021-07-22. Duration: 00:28:19. Flag: Clean.
Tags: ebooks, epub, scripting, calibre.
Response to HPR 3367 I describe how to specify page numbers in an EPUB eBook.

hpr3383 :: My gEeeky Experiment - Part 1 hosted by Claudio Miranda

Released: 2021-07-21. Duration: 00:17:09. Flag: Clean.
Tags: asus,eeepc,openbsd,bsd,linux.
ClaudioM talks about how he revived his lowly Asus Eee PC 901 netbook with OpenBSD.

hpr3382 :: How I fixed a fault on my car for free thanks to YouTube hosted by MrX

Released: 2021-07-20. Duration: 00:12:40. Flag: Explicit.
Tags: Car, Repair, Hack, DIY.
How I fixed a fault on my car for free and as an added bonus without injuring myself!

Older Shows

Get a full list of all our shows.