1. IT-Security >
  2. Podcasts


ArabicEnglishFrenchGermanGreekItalianJapaneseKoreanPersianPolishPortugueseRussianSpanishTurkishVietnamese
Anzeige

Podcasts


Suchen

RSS-News Quellen: 1x
Kategorien unterhalb von Podcasts: 0x
RSS Feed dieser Podcasts Kategorie: RSS-Feed Podcasts

Seitennavigation

Seite 1 von 2 Seiten (Bei Beitrag 1 - 35)
37x Beiträge in dieser Kategorie

Nächste 2 Seite | Letzte Seite
[ 2 ]

HPR2720: Download youtube channels using the rss feeds

Podcasts vom 04.01.2019 um 01:00 Uhr | Quelle hackerpublicradio.org

I had a very similar problem to Ahuka aka Kevin, in hpr2675 :: YouTube Playlists. I wanted to be able to download an entire youtube channel and store them so that I could play them in the order that they were posted.
See previous episode hpr2705 :: Youtube downloader for channels.

The problem with the original script is that it needs to download and check each video in each channel and it can crawl to a halt on large channels like EEEVblog.

The solution was given in hpr2544 :: How I prepared episode 2493: YouTube Subscriptions - update with more details in the full-length notes.

  1. Subscribe:
    Subscriptions are the currency of YouTube creators so don't be afraid to create an account to subscribe to the creators. Here is my current subscription_manager.opml to give you some ideas.
  2. Export:
    Login to https://www.youtube.com/subscription_manager and at the bottom you will see the option to Export subscriptions. Save the file and alter the script to point to it.
  3. Download: Run the script youtube-rss.bash

How it works

The first part allows you to define where you want to save your files. It also allows you to set what videos to skip based on length and strings in their titles.

savepath="/mnt/media/Videos/channels"
subscriptions="${savepath}/subscription_manager.opml"
logfile="${savepath}/log/downloaded.log"
youtubedl="/mnt/media/Videos/youtube-dl/youtube-dl"
DRYRUN="echo DEBUG: "
maxlength=7200 # two hours
skipcrap="fail |react |live |Best Pets|BLOOPERS|Kids Try"

After some checks and cleanup, we can then parse the opml file. This is an example of the top of mine.

<?xml version="1.0"?>
<opml version="1.1">
  <body>
    <outline text="YouTube Subscriptions" title="YouTube Subscriptions">
      <outline text="Wintergatan" title="Wintergatan" type="rss" xmlUrl="https://www.youtube.com/feeds/videos.xml?channel_id=UCcXhhVwCT6_WqjkEniejRJQ"/>
      <outline text="Primitive Technology" title="Primitive Technology" type="rss" xmlUrl="https://www.youtube.com/feeds/videos.xml?channel_id=UCAL3JXZSzSm8AlZyD3nQdBA"/>
      <outline text="John Ward" title="John Ward" type="rss" xmlUrl="https://www.youtube.com/feeds/videos.xml?channel_id=UC2uFFhnMKyF82UY2TbXRaNg"/>

Now we use the xmlstarlet tool to extract each of the urls and also the title. The title is just used to give some feedback, while the url needs to be stored for later. Now we have a complete list of all the current urls, in all the feeds.

xmlstarlet sel -T -t -m '/opml/body/outline/outline' -v 'concat( @xmlUrl, " ", @title)' -n "${subscriptions}" | while read subscription title
do
  echo "Getting "${title}""
  wget -q "${subscription}" -O - | xmlstarlet sel -T -t -m '/_:feed/_:entry/media:group/media:content' -v '@url' -n - | awk -F '?' '{print $1}'  >> "${logfile}_getlist"
done

The main part of the script then counts the total so we can have some feedback while we are running it. It then pumps the list from the previous step into a loop which first checks to make sure we have not already downloaded it.

count=1
total=$( sort "${logfile}_getlist" | uniq | wc -l )

sort "${logfile}_getlist" | uniq | while read thisvideo
do 
  if [ "$( grep "${thisvideo}" "${logfile}" | wc -l )" -eq 0 ];
  then

The next part takes advantage of the youtube-dl --dump-json command which downloads all sorts of information about the video which we store to query later.

    metadata="$( ${youtubedl} --dump-json ${thisvideo} )"
    uploader="$( echo $metadata | jq '.uploader' | awk -F '"' '{print $2}' )"
    title="$( echo $metadata | jq '.title' | awk -F '"' '{print $2}' )"
    upload_date="$( echo $metadata | jq '.upload_date' | awk -F '"' '{print $2}' )"
    id="$( echo $metadata | jq '.id' | awk -F '"' '{print $2}' )"
    duration="$( echo $metadata | jq '.duration' )"

Having the duration, we can skip long episodes.

    if [[ -z ${duration} || ${duration} -le 0 ]]
    then
      echo -e "nError: The duration "${length}" is strange. "${thisvideo}"."
      continue
    elif [[ ${duration} -ge ${maxlength} ]]
    then
      echo -e "nFilter: You told me not to download titles over ${maxlength} seconds long "${title}", "${thisvideo}""
      continue
    fi

Or videos that don't interest us.

    if [[ ! -z "${skipcrap}" && $( echo ${title} | egrep -i "${skipcrap}" | wc -l ) -ne 0 ]]
    then
      echo -e "nSkipping: You told me not to download this stuff. ${uploader}: "${title}", "${thisvideo}""
      continue
    else
      echo -e "n${uploader}: "${title}", "${thisvideo}""
    fi

Now we have a filtered list of urls we do want to keep. These we also save the description in a text file with the video id if we want to refer to it later.

    echo ${thisvideo} >> "${logfile}_todo"
    echo -e $( echo $metadata | jq '.description' ) > "${savepath}/description/${id}.txt"
  else
    echo -ne "rProcessing ${count} of ${total}"
  fi
  count=$((count+1))
done
echo ""

And finally we download the actual videos saving each channel in its own directory. The file names is first an ISO8601 date, then the title stored as ASCII with no space or ampersands. I then use a "⋄" as a delimiter before the video id.

# Download the list
if [ -e "${logfile}_todo" ];
then
  cat "${logfile}_todo" | ${youtubedl} --batch-file - --ignore-errors --no-mtime --restrict-filenames --format mp4 -o "${savepath}"'/%(uploader)s/%(upload_date)s-%(title)s⋄%(id)s.%(ext)s'
  cat "${logfile}_todo" >> ${logfile}
fi

Now you have a fast script that keeps you up to date with your feeds.


Newsbewertung

Weiterlesen

HPR2719: Bash Tips - 17

Podcasts vom 03.01.2019 um 01:00 Uhr | Quelle hackerpublicradio.org

Bash Tips - 17 (Additional auxiliary Bash tips)

Arrays in Bash

This is the second of a small group of shows on the subject of arrays in Bash. It is also the seventeenth show in the Bash Tips sub-series.

In the last show we saw the two types of arrays, and learned about the multiple ways of creating them and populating them. We also looked at how array elements and entire arrays are accessed.

Now we want to continue looking at array access and some of the various parameter expansion operations available.

Long notes

I have provided detailed notes as usual for this episode, and these can be viewed here.

Links


Newsbewertung

Weiterlesen

HPR2718: Genre In Storytelling

Podcasts vom 02.01.2019 um 01:00 Uhr | Quelle hackerpublicradio.org

Many people see genres as being largely interchangeable, but are they really? Why can some stories only be told in a particular genre? When are genre stories truly alike? And when are setting, character, and plot more important than genre? Lostnbronx takes a quick, rambling look at this complicated subject.


Newsbewertung

Weiterlesen

HPR2717: Mobile Device Security

Podcasts vom 01.01.2019 um 01:00 Uhr | Quelle hackerpublicradio.org

Introduction

Hello and welcome to Hacker Public Radio, I’m Edward Miro and for this episode I decided to address mobile device security. As with most of the research and articles I’ve written in the past, these are geared toward standard users in a business setting and are meant to be a jumping off point for further research and to be a foundation for cyber security 101 level training classes. If you like what I do, and want to have me come speak to your team, feel free to email me.

As an information security researcher, I have noticed a trend in what potential clients lately have been interested in: cell phones. Almost everyone I have consulted for in the area of private investigations make this area their main priority. This makes sense as users have started to transition to using mobile devices more and more. Not only do cell phones represent the main conduit to the internet for a huge chunk of people, but many use them for work also. Many companies have smartly presented policies against this, but there are still many organizations that allow bring-your-own-device style implementations. In the following podcast I will try to define the threats, defense and considerations in very broad strokes.

Cell phones differ from a standard hacking target in a few ways. For the most part, many of the same vectors are still valid. Remote code execution however is more rare, but not out of the question. I’m going to attempt to present these different vectors in an ascending list of what is most likely to be used as an attack, in my humble (and possibly ignorant) opinion.

1. Passive Surveillance

This vector is one many in the hacking world will already be familiar with and it is a major concern for mobile devices as well. Attackers can monitor an access point where the mobile device is connected and collect packets in all the usual ways. Open public WiFi is a treasure trove and tons of data that’s being sent in the clear can be collected, analyzed and leveraged by attackers.

Defense here is a bit more complicated for the general user, but shouldn’t be too intrusive for most:

  1. Use a VPN on your mobile devices.
  2. Switch to a DNS provider that provides secure DNSSEC.
  3. Implement proper encryption on access points.

2. Spyware

Many commercial spyware applications are readily available on both of the main app stores. The challenges for attackers lie in either gaining physical access to the unlocked device to install the spyware, or tricking the user into installing it themselves. Most often the target’s spouse or close contact does this. Some of these apps can be disguised to look like innocuous applications as a feature, but with devices that are rooted/jailbroken, they can be completely hidden from the user. I found a few surveys that state the average smart phone user has about 30 apps installed. I don’t think it’s unreasonable to suspect the average person wouldn’t notice a second calculator or calendar app. These apps feature the full gamut of what you’d expect from a spyware app.

Defense against spyware is pretty simple:

  1. Don’t allow unsupervised access to your device.
  2. Use a strong passcode or biometric lock.
  3. Remove unused applications and be aware of new apps that may pop up.
  4. Don’t root or jailbreak your device.

3. Social Engineering

The tried and true vector that has always worked and will continue to work is social engineering. It doesn’t matter what kind of device a target is using if you can get them to click a malicious link, open a malicious attachment, or disclose their password to the attackers. With a user’s password you can conduct a vast amount of surveillance through their Google or Apple account. Not to mention leverage their password into all their other accounts as most users still use the same password for everything. We can also callback to the previous section on spyware by mentioning that many users are already familiar with enabling the installation of 3rd party applications and can be tricked into installing a cleverly disguised spyware application.

Basic OPSEC recommendations are applicable here:

  1. Don’t click strange or unsolicited links or attachments on your devices.
  2. Never disclose your password to anyone through a text message or voice call.
  3. Don’t install 3rd party applications. I’ll extend this to say not to install any shady or questionable apps, even ones hosted by the app stores. There have been instances of vetted apps being malicious.

4. IMSI catchers/Femtocells

I refer to these as DIY Stingrays. Stingrays are devices used by law enforcement to track and surveil cell phone traffic. These devices emulate a cell tower or boost cell phone signals when used in a legitimate way. Mobile phones are designed to prefer using stations that are the closest and strongest. Any technically proficient attacker can DIY one of these devices for not a lot of money. When an attacker deploys one of these devices, the target’s phone usually has no idea that the device isn’t an official cell tower and happily connects and passes traffic through it. The rogue stations can then be configured to pass the traffic on to an authentic tower and the user will have no idea. These rogue towers can not only collect identifying information about the mobile device that can be used to track or mark a target, they can also monitor voice calls, data, and SMS, as well as perform man-in-the-middle attacks. Often they can disable the native encryption of the target’s phone as well.

Defense against this vector is a bit more complicated:

  1. As before, use a VPN.
  2. Use Signal or other encrypted communication apps.
  3. Avoid disclosing sensitive information during voice calls.
  4. There is software that has been developed to detect and notify the user when a rogue station has been detected, but this is not going to be super helpful for standard users. There are also maps online of known cell towers and it is possible to use software to identify your connected tower.

5. Exploits

Speaking very generally, this attack vector is for the most part less of a concern (depending on your particular threat level), but we all know that the chance of this happening in the wild is probably remote for most people. The technical implementations of exploits such as Rowhammer, Stagefright, and Blueborne are well outside the scope of this particular talk, but we would be incorrect to not mention them and what can be done to protect against them. And we should also pay special attention to more and more exploits being developed to attack mobile devices as attackers have started putting a lot of attention in this area. Even though many of these vulnerabilities are being patched, we all know many users are still using old versions of Android and iOS, and many devices are simply outside the support period offered by the manufacturers and will never be updated past a certain point. Couple that with the general idea that mobile devices (or any device running a non Windows based OS) are “safer” because less exploits exist for them is currently a very poor assumption. This will probably get worse as the cost of keeping up with new devices now being over $1000 and many users won’t be able to get devices that are constantly being patched.

What we can do:

  1. Keep your mobile devices updated with most current OS updates and carrier settings. Also keep applications updated. I don’t know how many times I’ve noticed friends or family with devices that are ready to be updated, but the notifications go ignored.
  2. If it’s possible, replace devices when they are outside the support period.
  3. Be paranoid, if it applies to you. What this means is when you use any computer or device, always remember that zero day exploits can exist for years before being disclosed. You could follow ALL the best OPSEC practices, and you could still be vulnerable to exploits that haven’t been disclosed and/or patched. This might not matter if you’re just a general user, but if you work for the government or do intelligence work, act as if.

Well, thank you for taking the time to listen to my basic introduction to cell phone cyber defense. I know most of the information I provided is only the tip of the iceberg and if current trends hold up, this will only get worse in the future. If you want to add to or correct any mistakes I may have made, like I stated in the introduction, feel free to email me and let’s have a conversation. I don’t claim to know all there is to know and love feedback and any opportunities to learn more or collaborate with others in the field.

Thanks again, and have a great 2019!


Newsbewertung

Weiterlesen

HPR2716: Really Simple YouTube

Podcasts vom 31.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

Here are the two links I mentioned that let you pull RSS feeds out of YouTube


Newsbewertung

Weiterlesen

HPR2715: About ONAP

Podcasts vom 28.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

So I went to the open networking trade show sponsored by the Linux Foundation with Ken Fallon’s help.

The first thing they talked about was ONAP.

https://www.onap.org/
https://en.wikipedia.org/wiki/ONAP


Newsbewertung

Weiterlesen

HPR2714: Airplane stalls and Angle of Attack

Podcasts vom 27.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

stalls, a primer on why aircraft fly, and don’t fly

YouTube video of stall with narration (35 seconds)

https://www.youtube.com/watch?v=SiOiVHUEYao

AoA gauge from T-38 manual

https://goo.gl/images/ZH5UYx

Some definitions

  • chord - an imaginary line from the front of the wing to the back

  • relative wind - movement of air relative to the chord

  • angle of attack - the angle of the chord of the wing to the relative wind

  • stall - a condition where the air on the top of the wing is not flowing smoothly over the wing

  • critical angle of attack - the angle that the wing becomes stalled

  • fun - stalling and spinning and aircraft when its safe to do so

  • scary - stalling and spinning and aircraft when you don’t want to

Things not mentioned

This discussion pertained to subsonic speeds, super sonic flight introduces a whole other realm of issues.

The wings of aircraft do not stall all at once. They are designed (usually) to stall from the wing root (where the wing is attached to the fuselage) towards the tips. This ensures good roll control at slow speed and into the stall. This stalling characteristic is achieved by designing twist in the wing (washout) allowing different parts of the wing to hit the critical angle of attack at different times.

The most dangerous situation that you can find yourself in is a low altitude situation where one wing is stalled more than the other. The airplane then enters a spin. The dangerous part is the low altitude. Spins are fun, and the plane is still controllable, but you need altitude to recover. A wise man told me when turning low to the ground keep your nose down and speed up.

Most light aircraft will shudder or buffet as you approach the critical angle of attack this happens because of the disturbed airflow hitting the aircraft’s fuselage or tail. In larger aircraft no (i.e. airliners) no feel is given naturally as the plane approaches a stalled condition so systems like stick shakers vibrate the control artificially as you approach the critical angle of attack as measured by the AoA sensors. DC-9 stick shaker, a big cell phone vibrator artificial stall warning is mandatory in fly-by-wire aircraft (i.e. Airbus, f-16) as well as pure hydraulic controls (i.e. Boeing 757)

Author: Brian
Created: 2018-12-01 Sat 07:34
Emacs 25.3.1 (Org mode 8.2.10)


Newsbewertung

Weiterlesen

HPR2713: Resources in 4x game

Podcasts vom 26.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

Raw resources are integral part for most 4x games. Here’s one way of modeling them in Haskell. I wanted a system that is easy to use, doesn’t require too much typing and is type safe.

RawResource is basic building block:

newtype RawResource a = RawResource { unRawResource :: Int }
    deriving (Show, Read, Eq)

It can be parametrised with anything, but I’m using three different types:

data Biological = Biological
data Mechanical = Mechanical
data Chemical = Chemical

Example of defining harvest being 100 units of biological raw resources:

  harvest :: RawResource Biological
  harvest = RawResource 100

Raw resources are often manipulated (added and subtracted mostly). Defining Num instance allows us to use them as numbers:

instance Num (RawResource t) where
    (+) (RawResource a) (RawResource b) = RawResource $ a + b
    (-) (RawResource a) (RawResource b) = RawResource $ a - b
    (*) (RawResource a) (RawResource b) = RawResource $ a * b
    abs (RawResource a) = RawResource $ abs a
    signum (RawResource a) = RawResource $ signum a
    fromInteger a = RawResource $ fromInteger a

For example, adding harvest to stock pile:

  stock :: RawResource Biological
  stock = RawResource 1000

  harvest :: RawResource Biological
  harvest = RawResource 100

  newStock = stock + harvest

Comparing size of two resource piles is common operation. Ord instance has methods we need for comparing:

instance Ord (RawResource t) where
    (<=) (RawResource a) (RawResource b) = a <= b

One function is enough, as rest is defined in terms of it. Sometimes (usually for reasons of optimization), one might want to define other functions too.

Another way to add bunch of resources of same type together is defining Monoid instance:

instance Semigroup (RawResource t) where
    (<>) a b = a + b

instance Monoid (RawResource t) where
    mempty = RawResource 0

For example, combining harvests of many fields can be achieved as:

  harvests :: [RawResource Biological]
  harvests = [RawResource 20, RawResource 50, RawResource 25]

  total :: RawResource Biological
  total = mappend harvests

All these functions keep track of type of resources being manipulated. Compiler will emit an error if two different types of resources are being mixed together.

Raw resources are often grouped together for specific purpose. This again uses phantom types to keep track the intended usage:

data RawResources a = RawResources
    { ccdMechanicalCost :: RawResource Mechanical
    , ccdBiologicalCost :: RawResource Biological
    , ccdChemicalCost :: RawResource Chemical
    } deriving (Show, Read, Eq)

data ResourceCost = ResourceCost
data ConstructionSpeed = ConstructionSpeed
data ConstructionLeft = ConstructionLeft
data ConstructionDone = ConstructionDone
data ResourcesAvailable = ResourcesAvailable

And in order to be able to combine piles of RawResources, we’ll define Semigroup and Monoid instances. Notice how both instances make use of Semigroup and Monoid instances of RawResource:

instance Semigroup (RawResources t) where
    (<>) a b = RawResources
        { ccdMechanicalCost = ccdMechanicalCost a <> ccdMechanicalCost b
        , ccdBiologicalCost = ccdBiologicalCost a <> ccdBiologicalCost b
        , ccdChemicalCost = ccdChemicalCost a <> ccdChemicalCost b
        }

instance Monoid (RawResources t) where
    mempty = RawResources
        { ccdMechanicalCost = mempty
        , ccdBiologicalCost = mempty
        , ccdChemicalCost = mempty
        }

For those interested seeing some code, source is available at https://github.com/tuturto/deep-sky/ (https://github.com/tuturto/deep-sky/tree/baa0807dd36b61fd02174b17c10013862af4ec18 is situation before lots of Elm related changes that I mentioned in passing in the previous episode)


Newsbewertung

Weiterlesen

HPR2712: Steganography

Podcasts vom 25.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

Did you find the hidden message contained in Klaatu's previous two episodes?

If not, Klaatu reveals how to find it in this one, how to duplicate it, and what makes good steganography.


Newsbewertung

Weiterlesen

HPR2711: Raspberry Pi 3A+ Review

Podcasts vom 24.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

Raspberry Pi 3A+ review

In this episode of HPR, I will do a quick review of the Raspberry Pi 3A+, the latest release of the Raspberry Pi foundation.

Raspberry Pi 3A+Raspberry Pi 3A+

Specs
The Raspberry Pi 3A+ has almost the same hardware as its big brother/sister the 3B+ :

  • BCM2837 BO SOC (system on chip), a quad core 64-bit ARM v8 processor, running at 1.4 GHz
  • On board wireless :
    • WiFi : 2.4 and 5 GHz 802.11 c/y/n/ac
    • Bluetooth : 4.2 and BLE
  • MicroSD card for storing the operating system and the data
  • Full size HDMI connector
  • 3.5 mm jack connector for audio and composite video output
  • MicroUSB connector for the power supply
  • 40-pin header with the same pinout as every other Raspberry Pi

The differences are :

  • Only one full size USB connector, instead of four on the 3B+
  • No ethernet connector
  • Only 512 MB or SDRAM instead of 1 GB on the 3B+

Size
The Raspberry Pi 3A+ is 6.7 x 5.6 cm (2.6 x 2.2 in) and 11 mm high (.45 in). But if you plug a ribbon in the header, then it takes a lot of space.

Raspberry Pi 3A+

In this case, it’s probably better to unsolder the header, and solder a right angle header in place, so the pins are pointing to the side of the board and not upwards

Raspberry Pi 3A+Raspberry Pi 3A+

With a bit of caution and the help of some desoldering wick, it’s not a complex operation, because there is no component near the GPIO header.

Of course if you plan on using a HAT, then you’re better off using the straight header. The Raspberry Pi 3A+ is actually the same size than a standard HAT.

Raspberry Pi 3A+Raspberry Pi 3A+

Use case

Since the Raspberry Pi 3A+ doesn’t have an ethernet port, I think I will not use it for server stuff like Mosquitto or Pi-Hole, for which a good network connection is required. Also, those servers sometimes need a keyboard and a mouse, and with only one USB port, that’s not too practical.

For me, the A+ will be used to upgrade projects currently using a Raspberry Pi ZeroW, and for which I need a little more power. The on board WiFi and the small form factor, combined with the extra power, makes the 3A+ an ideal replacement for the ZeroW.

Credits

The sound used for the opening and closing sequence is Speaker X-Clash by Daniel H, and is released under a CC-BY-NC license.


Newsbewertung

Weiterlesen

HPR2710: Youtube downloader for channels

Podcasts vom 21.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

I had a very similar problem to Ahuka aka Kevin, in hpr2675 :: YouTube Playlists. I wanted to be able to download an entire youtube channel and store them so that I could play them in the order that they were posted.

Add the url's to a file called subscriptions.txt.

#LASTRUN: 20181030
# /home/ken/sourcecode/personal/bestofyoutube/youtube-channel-watcher.bash
#
# Big Clive 
https://www.youtube.com/channel/UCtM5z2gkrGRuWd0JQMx76qA	20181030
# Essential Craftsman
https://www.youtube.com/channel/UCzr30osBdTmuFUS8IfXtXmg

Then run the script

#!/bin/bash
# Downloads videos from youtube based on selection from http://thebestofyoutube.com
# (c) Ken Fallon http://kenfallon.com
# Released under the CC-0

savepath="/mnt/media/Videos/channels"
subscriptions="${savepath}/subscriptions.txt"
YOUNGERTHAN="20010101"
RUNDATE=$(date +%Y%m%d)
youtubedl="/home/ken/sourcecode/youtube-dl/youtube-dl"
#DRYRUN="echo DEBUG: "

if [ ! -e "${subscriptions}" ]
then
	echo "Cannot find subscription file "${subscriptions}""
	exit 1
fi

if [ "$(grep "#LASTRUN: " "${subscriptions}" | wc -l )" -eq 0 ]
then
	sed --follow-symlinks '1s/^/#LASTRUN: n/' -i "${subscriptions}"
fi

# Read the subscriptions
cat "${subscriptions}" | grep -v '#' | while read channel_info
do
	if [ "$(echo "${channel_info}" | grep -P 't' | wc -l )" -eq 0 ]
	then
		DATEAFTER="--dateafter ${YOUNGERTHAN}"
	else
		DATEAFTER="--dateafter $(echo "${channel_info}" | awk '{print $NF}' )"
	fi
	channel="$(echo "${channel_info}" | awk '{print $1}' )"
	echo "Processing Channel "${channel}" since ${DATEAFTER}"
	${DRYRUN} ${youtubedl} ${DATEAFTER} --ignore-errors --no-mtime --restrict-filenames --format mp4 -o ${savepath}'/%(uploader)s/%(upload_date)s-%(title)s⋄%(id)s.%(ext)s' ${channel}
	${DRYRUN} sed --follow-symlinks "s,${channel}.*$,${channel}t${RUNDATE},g" -i "${subscriptions}"
done

${DRYRUN} sed --follow-symlinks "s/#LASTRUN: .*$/#LASTRUN: ${RUNDATE}/" -i "${subscriptions}"

Newsbewertung

Weiterlesen

HPR2710: Youtube downloader for channels

Podcasts vom 21.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

I had a very similar problem to Ahuka aka Kevin, in hpr2675 :: YouTube Playlists. I wanted to be able to download an entire youtube channel and store them so that I could play them in the order that they were posted.

Add the url's to a file called subscriptions.txt.

#LASTRUN: 20181030
# /home/ken/sourcecode/personal/bestofyoutube/youtube-channel-watcher.bash
#
# Big Clive 
https://www.youtube.com/channel/UCtM5z2gkrGRuWd0JQMx76qA	20181030
# Essential Craftsman
https://www.youtube.com/channel/UCzr30osBdTmuFUS8IfXtXmg

Then run the script

#!/bin/bash
# Downloads videos from youtube based on selection from http://thebestofyoutube.com
# (c) Ken Fallon http://kenfallon.com
# Released under the CC-0

savepath="/mnt/media/Videos/channels"
subscriptions="${savepath}/subscriptions.txt"
YOUNGERTHAN="20010101"
RUNDATE=$(date +%Y%m%d)
youtubedl="/home/ken/sourcecode/youtube-dl/youtube-dl"
#DRYRUN="echo DEBUG: "

if [ ! -e "${subscriptions}" ]
then
	echo "Cannot find subscription file "${subscriptions}""
	exit 1
fi

if [ "$(grep "#LASTRUN: " "${subscriptions}" | wc -l )" -eq 0 ]
then
	sed --follow-symlinks '1s/^/#LASTRUN: n/' -i "${subscriptions}"
fi

# Read the subscriptions
cat "${subscriptions}" | grep -v '#' | while read channel_info
do
	if [ "$(echo "${channel_info}" | grep -P 't' | wc -l )" -eq 0 ]
	then
		DATEAFTER="--dateafter ${YOUNGERTHAN}"
	else
		DATEAFTER="--dateafter $(echo "${channel_info}" | awk '{print $NF}' )"
	fi
	channel="$(echo "${channel_info}" | awk '{print $1}' )"
	echo "Processing Channel "${channel}" since ${DATEAFTER}"
	${DRYRUN} ${youtubedl} ${DATEAFTER} --ignore-errors --no-mtime --restrict-filenames --format mp4 -o ${savepath}'/%(uploader)s/%(upload_date)s-%(title)s⋄%(id)s.%(ext)s' ${channel}
	${DRYRUN} sed --follow-symlinks "s,${channel}.*$,${channel}t${RUNDATE},g" -i "${subscriptions}"
done

${DRYRUN} sed --follow-symlinks "s/#LASTRUN: .*$/#LASTRUN: ${RUNDATE}/" -i "${subscriptions}"

Newsbewertung

Weiterlesen

HPR2709: Bash Tips - 16

Podcasts vom 20.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

Bash Tips - 16 (Further auxiliary Bash tips)

Arrays in Bash

This is the first of a small group of shows on the subject of arrays in Bash. It is also the sixteenth show in the Bash Tips sub-series.

We have encountered Bash arrays at various points throughout this sub-series, and have even seen a number of examples, but the subject has never been examined in detail. This group of shows intends to make good this deficiency.

Long notes

I have provided detailed notes as usual for this episode, and these can be viewed here.

Links


Newsbewertung

Weiterlesen

HPR2708: Ghostscript

Podcasts vom 19.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

Ghostscript is the open source implementation of Postscript. You can read its docs online.

To compress a big PDF into something possibly smaller:


$ gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dPDFSETTINGS=/screen -dBATCH -sOutputFile=output.pdf example.pdf

That renders basically the same PDF with all images down-res'd to 72 DPI. Other valid setting profiles are ebook, printer, and prepress.

To render a version of a PDF without any raster images in it, making it cheaper and faster to print:


gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dPDFSETTINGS=/screen -dBATCH -dFILTERIMAGE -sOutputFile=output.pdf example.pdf

The FILTERIMAGE option drops raster images from the file. The FILTERVECTOR option filters vector images, and FILTERTEXT filters text.

If pdftk is not available for your OS, you can use pdf-stapler instead for cutting and concatenating PDF files. It doesn't deal with metadata as well as pdftk does, however.

It's worth noting that pdftk is available as a snap package https://snapcraft.io/pdftk.

It's also worth noting that this is actually episode 2 in a series about steganography.


Newsbewertung

Weiterlesen

HPR2707: Steganalysis 101

Podcasts vom 18.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

1. Introduction

Hello and welcome to Hacker Public Radio, I’m Edward Miro and I’ve been a fan of HPR for a while now and really love its collaborative and random nature. It’s always been important for me to support the hacking community. I always take any opportunity to give back to this community who have given me so much throughout the years. I’ve also always subscribed to the idea that the best way to learn something is by teaching and I hope to do a good job for all you listeners. This talk is on mystical art of steganalysis which is the process of identifying the presence of and decrypting (hopefully) steganography.

2. What is steganography?

I’m into hacking, but I’m not a professional hacker. Usually I call myself a hobbyist. I like CTFs, crypto challenges, lots of stuff from Vulnhub or OverTheWire, things like that. I’ll provide some links in the end if anyone is interested, but for those who aren’t familiar a CTF, or Capture The Flag, it’s a kind of game that helps you get better at hacking. These days there are tons of VMs that are setup to be intentionally vulnerable to different techniques or attacks. You load the VM and pretend it’s a server you want to attack and follow your standard hacking protocols. Some are setup to be boot to root challenges where you ‘win’ when you get root and some are setup with flags that you can find hidden in the target worth points. There are in person and online CTFs and they’ve gotten pretty popular with the National Cyber League being a major competition. Some are easy, some are really hard and most have really good write-ups that can teach you so much about INFOSEC, penetration testing and actually let you practice the techniques in a relatively easy and legal way.

Where steganography comes in to this discussion is that it’s an element you sometimes see used in the kinds of challenges I mentioned previously and also in alternate reality games, online recruitment challenges by national agencies/big tech companies and militarys. They are even used in real world espionage and intelligence work or super spooky secret challenges like Cicada 3301.

Simply put steganography (and I’m pasting this straight out of Wikipedia): “is the practice of concealing a file, message, image, or video within another file, message, image, or video”. Steganography is used to hide secrets in plain sight. It’s a way to send a message, without anyone detecting that a message is even being sent.

I’ll give you more examples in the next section, but imagine a letter that has a secret written in invisible ink. Only the sender and receiver should know about the invisible ink and any eavesdroppers should be none the wiser. This simple example has been used by countless prisoners whose mail is routinely read and examined. Terrorists and spies the world over also use steganography and are known to embed messages in an image and post it online. With how many image hosting sites there are, with millions of people posting to them billions of images day in and day out, you can see why steganography can be such a challenge to combat. Before I move on to some more specific examples I want to stress again that I’m not an expert on cryptography or steganography. While researching for this podcast it’s overwhelmingly clear that you could spend your whole career focused on only steganography. This talk is just a primer on the subject and only the tip of the iceberg.

3. Examples (also from Wikipedia, the great repository of all knowledge)

  • Analog:
    • Head shaving
    • Invisible ink
    • Knots tied into ropes
    • Messages hidden under stamps on envelopes
    • Mixed typeface
    • Using a grille cipher
    • Sending messages via newspaper classifieds
  • Digital:
    • Noise in images or sound files
    • Text commented out in source html or other code
    • Using different color text
    • Fractionalized comments
    • Audio signals/spectro
    • Hidden control characters and non printing Unicode

The possibilities are almost endless for how this technique can be applied.

4. Why should we care?

When we are doing a CTF or crypto challenge and are presented with an image or media file we are pretty well assured there’s something in there, though not every image you find while doing a challenge or CTF will utilize steganography so don’t overanalyze. I’ve known people who are really into alternate reality games spending 100s of hours doing spectrographic analysis and for our purpose(and the scope of this podcast), there should be some clue that steganography is being used. The challenge then becomes how we direct our work flow as to not waste any time and be the most efficient in cracking that particular part the puzzle. There are MANY stego tools out there, some of them homebrewed, and unless the designer of the challenge puts in a clue, you might spend hours trying different algorithms or tools. And even if you do, there’s no guarantee you’ll get anything at all. A lot of the tools that will be mentioned in the next section rely on fingerprinting how known algorithms process data. This is not only a big problem for hackers like us with our CTFs and games, but even more so for governments who are charged with keeping us safe. So if you’re looking at possible steganography, you need to build a good workflow and I noticed a post on Reddit a few weeks ago with a user asking about image forensics. There was a comment posted that was so good I forwarded it to my hacking friends and it inspired me to do this podcast. I’m using the comment as a potential framework for my own personal work with images and steganography. It helped me to develop my own protocol and I wanted to share it with you all and if anyone wants to expand on it or improve it please do so. Thank you /u/Alexeyan!

5. Proposed work flow

This is coming straight out of the post on Reddit. I thought about rewriting it, but it didn’t seem necessary and I will be giving the author full credit. I add a couple more tools on at the bottom and a few closing thoughts:

  • First: Look at the image. Maybe it tells you something important.

  • Use binwalk to check for other file type signatures in the image file.

  • Use Exiftool to check for any interesting exif-metadata.

  • Use stegsolve and switch through the layers and look for abnormalities.

  • Maybe the Flag is painted in the LSB image, or some QR-Code.

  • Maybe there are random pixels that look strange in a certain layer, that’s a hint for Bit-Stego.

  • Use zsteg to automatically test the most common bitstegos and sort by %ascii-in-results. (This one auto-solves about 50% of all image stego challenges)

  • If the file is a png, you can check if the IDAT chunks are all correct and correctly ordered.

  • Check with the strings tool for parts of the flag. If you found for example “CTF{W” in a chunk, check what is on that position in other IDAT chunks.

  • The harder ones can be a lot more tricky though.. JPG coefficiency manipulation, Frequency analysis, …

  • But usually those are frowned upon, because they require a lot of guessing (if no hiding tool is provided)

Some other go to tools not mentioned above:

  • Stegdetect
  • DIIT(Digital Invisible Ink Toolkit )
  • StegSecret
  • ILook Investigator (for law enforcement)

Detecting steganography is hard work. There are computer scientists who do only this. While we aren’t at that level for the information being presented here, it will require a lot of digging and trying different tools. Hopefully following these steps will help identify the more common techniques in an easier way than trial and error.

One last thing I want to mention is that part of how I see detecting steganography in CTFs or cyptochallenges is having a certain mindset and always looking at things in various layers. I try to look at everything within the challenge as if there could be something right in front of my eyes. I mentally flip through different layers and see the codes within the codes. And remember if you’re playing an alternate reality game, a CTF or a crypto challenge, generally speaking, the designers want you to play through the game. They will leave clues if you need them. They want the players to get to the end. Don’t overthink things.

Well that’s all I’ve got for today. I hope you enjoyed this podcast and got something useful out of it. Like I said in the introduction, I’m Edward Miro. Have fun, and good luck!

6. Sources


Newsbewertung

Weiterlesen

HPR2706: Why I love the IBM AS/400 computer systems

Podcasts vom 17.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

This is a talk about my love for the IBM family of AS/400 computer systems.

Although it’s a very hacker unfriendly system there is still much to admire and love.

It’s completely different from anything else which makes it nice but also very likely to disappear in few years from now. To prevent that piece of computing history to vanish I started a small initiative called http://www.as400museum.org/. It’s just me, but it does show my intention with the system.


Newsbewertung

Weiterlesen

HPR2705: Evidence-based Medicine

Podcasts vom 14.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

Basing medical care and treatment on the scientific evidence should be the norm, but frequently it is not. Doctors may treat based on how they have always done it, or how other doctors do it (i.e. best practices), but there is a movement now to reorient medicine to follow the best scientific guidelines.


Newsbewertung

Weiterlesen

HPR2704: Intro to Scribus

Podcasts vom 13.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

Scribus is a page layout application. If you are familiar with common publishing industry tools, then Scribus will be very familiar to you, but if you're used to word processors or graphic applications, then Scribus will probably confuse you. In this episode, Klaatu talks about the workflow of page layout, and how to do some basic tasks in Scribus.

The example files Klaatu produces in Scribus are available at http://slackermedia.info/tank/scribus-by-example.tar.gz

Fair warning: this episode is actually "about" steganography. The key you need is OGG.


Newsbewertung

Weiterlesen

HPR2703: Fog of war in Yesod based game

Podcasts vom 12.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

Duality of the universe: there's true state of the universe used in simulation and there's state the the players perceive. These most likely will always be in conflict. One possible solution is to separate these completely. Perform simulation in one system and record what players see in other.

For every type of entity in the game, there's two sets of data: real and reported. Reports are tied to time and faction. Examples are given for planets. Thus, we have Planet, PlanetReport and CollatedPlanetReport. First is the real entity, second is report of that entity tied in time and faction. Third one is aggregated information a faction has of given entity. In database two first ones are:


Planet json
    name Text
    position Int
    starSystemId StarSystemId
    ownerId FactionId Maybe
    gravity Double
    SystemPosition starSystemId position
    deriving Show

PlanetReport json
    planetId PlanetId
    ownerId  FactionId Maybe
    starSystemId StarSystemId
    name Text Maybe
    position Int Maybe
    gravity Double Maybe
    factionId FactionId
    date Int
    deriving Show

Third one is defined as a datatype:


data CollatedPlanetReport = CollatedPlanetReport
    { cprPlanetId :: Key Planet
    , cprSystemId :: Key StarSystem
    , cprOwnerId  :: Maybe (Key Faction)
    , cprName     :: Maybe Text
    , cprPosition :: Maybe Int
    , cprGravity  :: Maybe Double
    , cprDate     :: Int
    } deriving Show

Data from database need to be transformed before working on it. Usually it's 1:1 mapping, but sometimes it makes sense to enrich it (turning IDs into names for example). For this we use ReportTransform type class:


-- | Class to transform a report stored in db to respective collated report
class ReportTransform a b where
    fromReport :: a -> b

instance ReportTransform PlanetReport CollatedPlanetReport where
    fromReport report =
	CollatedPlanetReport (planetReportPlanetId report)
			     (planetReportStarSystemId report)
			     (planetReportOwnerId report)
			     (planetReportName report)
			     (planetReportPosition report)
			     (planetReportGravity report)
			     (planetReportDate report)

To easily combine bunch of collated reports together, we define instances of semigroup and monoid for collated report data. Semigroup defines an associative binary operation (<>) and monoid defines a zero or empty item (mempty). My explanation about Monoid and Semigroup were a bit rambling, so maybe have a look at https://wiki.haskell.org/Monoid which explains it in detail.


instance Semigroup CollatedPlanetReport where
    (<>) a b = CollatedPlanetReport (cprPlanetId a)
				    (cprSystemId a)
				    (cprOwnerId a <|> cprOwnerId b)
				    (cprName a <|> cprName b)
				    (cprPosition a <|> cprPosition b)
				    (cprGravity a <|> cprGravity b)
				    (max (cprDate a) (cprDate b))

instance Monoid CollatedPlanetReport where
    mempty = CollatedPlanetReport (toSqlKey 0) (toSqlKey 0) Nothing Nothing Nothing Nothing 0

In some cases there might be a list of collated reports that are about different entities of same type (several reports for every planet in solar system). For those cases, we need a way to tell what reports belong together:


-- | Class to indicate if two reports are about same entity
class Grouped a where
    sameGroup :: a -> a -> Bool

instance Grouped PlanetReport where
    sameGroup a b =
	planetReportPlanetId a == planetReportPlanetId b

After this, processing a list of reports for same entity is short amount of very general code:


-- | Combine list of reports and form a single collated report
--   Resulting report will have facts from the possibly partially empty reports
--   If a fact is not present for a given field, Nothing is left there
collateReport :: (Monoid a, ReportTransform b a) => [b] -> a
collateReport reports = mconcat (map fromReport reports)

For reports of multiple entities is bit more complex, as they need to be sorted first, but the code is similarly general:


-- | Combine list of reports and form a list of collated reports
--   Each reported entity is given their own report
collateReports :: (Grouped b, Monoid a, ReportTransform b a) => [b] -> [a]
collateReports [] = []
collateReports [email protected](x:_) = collateReport itemsOfKind : collateReports restOfItems
    where split = span (sameGroup x) s
	  itemsOfKind = fst split
	  restOfItems = snd split

Final step is to either render reports as HTML or send them as JSON back to client. For JSON case we need one more type class instance (ToJSON) that can be automatically generated. After that handler function can be defined. After authenticating the user and checking that they are member of a faction, reports of specific planet (defined by its primary key) are retrieved from database, collated, turned into JSON and sent back to client:


$(deriveJSON defaultOptions {fieldLabelModifier = drop 3} ''CollatedPlanetReport)

getApiPlanetR :: Key Planet -> Handler Value
getApiPlanetR planetId = do
    (_, _, fId) <- apiRequireFaction
    loadedPlanetReports <- runDB $ selectList [ PlanetReportPlanetId ==. planetId
					      , PlanetReportFactionId ==. fId ] [ Asc PlanetReportDate ]
    let planetReport = collateReport $ map entityVal loadedPlanetReports :: CollatedPlanetReport
    return $ toJSON planetReport

For those interested seeing some code, source is available at https://github.com/tuturto/deep-sky/ (https://github.com/tuturto/deep-sky/tree/baa0807dd36b61fd02174b17c10013862af4ec18 is situation before lots of Elm related changes that I mentioned in passing in the previous episode)


Newsbewertung

Weiterlesen

HPR2703: Fog of war in Yesod based game

Podcasts vom 12.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

Duality of the universe: there's true state of the universe used in simulation and there's state the the players perceive. These most likely will always be in conflict. One possible solution is to separate these completely. Perform simulation in one system and record what players see in other.

For every type of entity in the game, there's two sets of data: real and reported. Reports are tied to time and faction. Examples are given for planets. Thus, we have Planet, PlanetReport and CollatedPlanetReport. First is the real entity, second is report of that entity tied in time and faction. Third one is aggregated information a faction has of given entity. In database two first ones are:


Planet json
    name Text
    position Int
    starSystemId StarSystemId
    ownerId FactionId Maybe
    gravity Double
    SystemPosition starSystemId position
    deriving Show

PlanetReport json
    planetId PlanetId
    ownerId  FactionId Maybe
    starSystemId StarSystemId
    name Text Maybe
    position Int Maybe
    gravity Double Maybe
    factionId FactionId
    date Int
    deriving Show

Third one is defined as a datatype:


data CollatedPlanetReport = CollatedPlanetReport
    { cprPlanetId :: Key Planet
    , cprSystemId :: Key StarSystem
    , cprOwnerId  :: Maybe (Key Faction)
    , cprName     :: Maybe Text
    , cprPosition :: Maybe Int
    , cprGravity  :: Maybe Double
    , cprDate     :: Int
    } deriving Show

Data from database need to be transformed before working on it. Usually it's 1:1 mapping, but sometimes it makes sense to enrich it (turning IDs into names for example). For this we use ReportTransform type class:


-- | Class to transform a report stored in db to respective collated report
class ReportTransform a b where
    fromReport :: a -> b

instance ReportTransform PlanetReport CollatedPlanetReport where
    fromReport report =
	CollatedPlanetReport (planetReportPlanetId report)
			     (planetReportStarSystemId report)
			     (planetReportOwnerId report)
			     (planetReportName report)
			     (planetReportPosition report)
			     (planetReportGravity report)
			     (planetReportDate report)

To easily combine bunch of collated reports together, we define instances of semigroup and monoid for collated report data. Semigroup defines an associative binary operation (<>) and monoid defines a zero or empty item (mempty). My explanation about Monoid and Semigroup were a bit rambling, so maybe have a look at https://wiki.haskell.org/Monoid which explains it in detail.


instance Semigroup CollatedPlanetReport where
    (<>) a b = CollatedPlanetReport (cprPlanetId a)
				    (cprSystemId a)
				    (cprOwnerId a <|> cprOwnerId b)
				    (cprName a <|> cprName b)
				    (cprPosition a <|> cprPosition b)
				    (cprGravity a <|> cprGravity b)
				    (max (cprDate a) (cprDate b))

instance Monoid CollatedPlanetReport where
    mempty = CollatedPlanetReport (toSqlKey 0) (toSqlKey 0) Nothing Nothing Nothing Nothing 0

In some cases there might be a list of collated reports that are about different entities of same type (several reports for every planet in solar system). For those cases, we need a way to tell what reports belong together:


-- | Class to indicate if two reports are about same entity
class Grouped a where
    sameGroup :: a -> a -> Bool

instance Grouped PlanetReport where
    sameGroup a b =
	planetReportPlanetId a == planetReportPlanetId b

After this, processing a list of reports for same entity is short amount of very general code:


-- | Combine list of reports and form a single collated report
--   Resulting report will have facts from the possibly partially empty reports
--   If a fact is not present for a given field, Nothing is left there
collateReport :: (Monoid a, ReportTransform b a) => [b] -> a
collateReport reports = mconcat (map fromReport reports)

For reports of multiple entities is bit more complex, as they need to be sorted first, but the code is similarly general:


-- | Combine list of reports and form a list of collated reports
--   Each reported entity is given their own report
collateReports :: (Grouped b, Monoid a, ReportTransform b a) => [b] -> [a]
collateReports [] = []
collateReports [email protected](x:_) = collateReport itemsOfKind : collateReports restOfItems
    where split = span (sameGroup x) s
	  itemsOfKind = fst split
	  restOfItems = snd split

Final step is to either render reports as HTML or send them as JSON back to client. For JSON case we need one more type class instance (ToJSON) that can be automatically generated. After that handler function can be defined. After authenticating the user and checking that they are member of a faction, reports of specific planet (defined by its primary key) are retrieved from database, collated, turned into JSON and sent back to client:


$(deriveJSON defaultOptions {fieldLabelModifier = drop 3} ''CollatedPlanetReport)

getApiPlanetR :: Key Planet -> Handler Value
getApiPlanetR planetId = do
    (_, _, fId) <- apiRequireFaction
    loadedPlanetReports <- runDB $ selectList [ PlanetReportPlanetId ==. planetId
					      , PlanetReportFactionId ==. fId ] [ Asc PlanetReportDate ]
    let planetReport = collateReport $ map entityVal loadedPlanetReports :: CollatedPlanetReport
    return $ toJSON planetReport

For those interested seeing some code, source is available at https://github.com/tuturto/deep-sky/ (https://github.com/tuturto/deep-sky/tree/baa0807dd36b61fd02174b17c10013862af4ec18 is situation before lots of Elm related changes that I mentioned in passing in the previous episode)


Newsbewertung

Weiterlesen

HPR2702: Audacity set up and response to episode 2658

Podcasts vom 11.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

Hi Guys and Girls in HPR land.

This is Tony Hughes in Blackpool in the UK back for another show. I normally talk about my own stuff but while it is related to what I have been doing lately this is a response to Al’s interview with Dave in Episode 2658 and how to setup Audacity to record and edit audio for best sound quality when podcasting.

I’ve recently joined the mintCast podcast team and have been editing and doing the post production of the audio recording for the last couple of episodes. The information that Dave provided during the show was invaluable in helping me in this task, I also have to give a shout out to Rob the previous host who also spent an hour and a half giving a tutorial on his post production work flow, but the additional information given by Dave in this show was also a big help.

I’ve now purchased a boom arm and pop filter for my mic to reduce any artefacts in the recording although as it is still attached to my desk I think I may need to invest in a shock mount although I’m not sure how it will attach to my current Boom arm. Ah well that’s a problem for another day.

As I said this was just a shout out to Al and Dave to say thanks for the show and I will save it for another day to do a show on my new post production work flow on the mintCast audio.

This is Tony Hughes saying goodbye for now.

https://mintcast.org/about-the-authors/tonyh/
[email protected]

http://hackerpublicradio.org/eps.php?id=2658


Newsbewertung

Weiterlesen

HPR2701: First impressions of the Odroid-go

Podcasts vom 10.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

I ramble on about my impressions of the Odroid-go, a 32 USD handheld system similar to a gameboy built to run game system emulators and various other free software. It’s also built to be harcked.

https://wiki.odroid.com/odroid_go/odroid_go

The summary is this is an easy to put together kit requiring no soldering, and runs classic console emulators pretty well. Well worth the 32 USD plus shipping in my opinion. Claims 10 hours of game play and that seems about right so far for me.

The systems emulated out of the box are:

NES, Game Gear, Gameboy, Gameboy Color, Sega Master System, ColecoVision. Other systems of similar or earlier vintages have emulators that you have to install separately and boot into to run. I don’t think it will emulate newer systems. No Gameboy Advance emulator and I don’t see a Mame emulator. However, I do think this ‘might’ support Mame for some of the early arcade games like Asteroids and Space Invaders.


Newsbewertung

Weiterlesen

HPR2701: First impressions of the Odroid-go

Podcasts vom 10.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

I ramble on about my impressions of the Odroid-go, a 32 USD handheld system similar to a gameboy built to run game system emulators and various other free software. It’s also built to be harcked.

https://wiki.odroid.com/odroid_go/odroid_go

The summary is this is an easy to put together kit requiring no soldering, and runs classic console emulators pretty well. Well worth the 32 USD plus shipping in my opinion. Claims 10 hours of game play and that seems about right so far for me.

The systems emulated out of the box are:

NES, Game Gear, Gameboy, Gameboy Color, Sega Master System, ColecoVision. Other systems of similar or earlier vintages have emulators that you have to install separately and boot into to run. I don’t think it will emulate newer systems. No Gameboy Advance emulator and I don’t see a Mame emulator. However, I do think this ‘might’ support Mame for some of the early arcade games like Asteroids and Space Invaders.


Newsbewertung

Weiterlesen

HPR2700: Episode 3000

Podcasts vom 07.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

On the 19th of September 2005 a group of individuals got together to release their first show on the podcast network "Today with a Techie".

The idea was to share knowledge through podcasting. Now 13 years, 2 months, 19 days later the project is still going strong, and you dear listener are a part of it.

Today marks the 2700th episode of "Hacker Public Radio" and coupled with the 300 shows from "Today with a Techie", marks the 3000th episode of this project.

A big thanks goes out to all 354 individual hosts who together contributed 1452 hours of shows to the archive.

There is about 50 giga bytes of mp3 files alone.

Which played back to back gives 60 days 11 hours 40 minutes 21 seconds of continuous play.

If you started listening today and played the shows 24 x 7 you wouldn't be finished listening until Monday, February 5th, 2019.

Of course by then there would be 39 additional shows released, so you still wouldn't be finished.

Despite all this we still don't have a wikipedia page. If you can, please take the time to create one for us. There is plenty of supporting information in the "In the Press" section of our about page.

So to mark the 3000th episode we are going to do nothing more than list the shows, host and summary where available.

Just doing that alone creates a whopping 7 and a half hour episode.

Are you l33t enough to listen to it all ?

Let's go.


Newsbewertung

Weiterlesen

HPR2700: Episode 3000

Podcasts vom 07.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

On the 19th of September 2005 a group of individuals got together to release their first show on the podcast network "Today with a Techie".

The idea was to share knowledge through podcasting. Now 13 years, 2 months, 19 days later the project is still going strong, and you dear listener are a part of it.

Today marks the 2700th episode of "Hacker Public Radio" and coupled with the 300 shows from "Today with a Techie", marks the 3000th episode of this project.

A big thanks goes out to all 354 individual hosts who together contributed 1452 hours of shows to the archive.

There is about 50 giga bytes of mp3 files alone.

Which played back to back gives 60 days 11 hours 40 minutes 21 seconds of continuous play.

If you started listening today and played the shows 24 x 7 you wouldn't be finished listening until Monday, February 5th, 2019.

Of course by then there would be 39 additional shows released, so you still wouldn't be finished.

Despite all this we still don't have a wikipedia page. If you can, please take the time to create one for us. There is plenty of supporting information in the "In the Press" section of our about page.

So to mark the 3000th episode we are going to do nothing more than list the shows, host and summary where available.

Just doing that alone creates a whopping 7 and a half hour episode.

Are you l33t enough to listen to it all ?

Let's go.


Newsbewertung

Weiterlesen

HPR2699: Bash Tips - 15

Podcasts vom 06.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

Bash Tips - 15

Pitfalls for the unwary Bash loop user

This is the fifteenth episode covering useful tips for Bash users. In the last episode we looked at the 'for' loop, and prior to that we looked at 'while' and 'until' loops. In this one I want to look at some of the loop-related issues that can trip up the unwary user.

Loops in Bash are extremely useful, and they are not at all difficult to use in their basic forms. However, there are some perhaps less than obvious issues that can result in unexpected behaviour.

Long notes

I have provided detailed notes as usual for this episode, and these can be viewed here.

Links


Newsbewertung

Weiterlesen

HPR2699: Bash Tips - 15

Podcasts vom 06.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

Bash Tips - 15

Pitfalls for the unwary Bash loop user

This is the fifteenth episode covering useful tips for Bash users. In the last episode we looked at the 'for' loop, and prior to that we looked at 'while' and 'until' loops. In this one I want to look at some of the loop-related issues that can trip up the unwary user.

Loops in Bash are extremely useful, and they are not at all difficult to use in their basic forms. However, there are some perhaps less than obvious issues that can result in unexpected behaviour.

Long notes

I have provided detailed notes as usual for this episode, and these can be viewed here.

Links


Newsbewertung

Weiterlesen

HPR2698: XSV for fast CSV manipulations - Part 1

Podcasts vom 05.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

XSV for fast CSV manipulations - Part 1: Basic Usage

https://github.com/BurntSushi/xsv

Introduction

xsv is a command line program for indexing, slicing, analyzing, splitting and joining CSV files. Commands should be simple, fast and composable:

  1. Simple tasks should be easy.
  2. Performance trade offs should be exposed in the CLI interface.
  3. Composition should not come at the expense of performance.

We will be using the CSV file provided in the documentation.

Commands covered in this episode

  • count - Count the rows of CSV data
  • headers - Show the headers of CSV data, or show the intersection of all headers between many CSV files
  • index - Create an index for a CSV file. This is very quick and provides constant time indexing into the CSV file.
  • frequency - Build frequency tables of each column in CSV data.
  • stats - Show basic types and statistics of each column in the CSV file. (i.e., mean, standard deviation, median, range, etc.)
  • sort - Sort CSV data
  • select - Select or re-order columns from CSV data.
  • slice - Slice rows from any part of a CSV file. When an index is present, this only has to parse the rows in the slice (instead of all rows leading up to the start of the slice).
  • search - Run a regex over CSV data. Applies the regex to each field individually and shows only matching rows.
  • table - Show aligned output of any CSV data using elastic tabstops.
  • flatten - A flattened view of CSV records. Useful for viewing one record at a time.

Newsbewertung

Weiterlesen

HPR2698: XSV for fast CSV manipulations - Part 1

Podcasts vom 05.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

XSV for fast CSV manipulations - Part 1: Basic Usage

https://github.com/BurntSushi/xsv

Introduction

xsv is a command line program for indexing, slicing, analyzing, splitting and joining CSV files. Commands should be simple, fast and composable:

  1. Simple tasks should be easy.
  2. Performance trade offs should be exposed in the CLI interface.
  3. Composition should not come at the expense of performance.

We will be using the CSV file provided in the documentation.

Commands covered in this episode

  • count - Count the rows of CSV data
  • headers - Show the headers of CSV data, or show the intersection of all headers between many CSV files
  • index - Create an index for a CSV file. This is very quick and provides constant time indexing into the CSV file.
  • frequency - Build frequency tables of each column in CSV data.
  • stats - Show basic types and statistics of each column in the CSV file. (i.e., mean, standard deviation, median, range, etc.)
  • sort - Sort CSV data
  • select - Select or re-order columns from CSV data.
  • slice - Slice rows from any part of a CSV file. When an index is present, this only has to parse the rows in the slice (instead of all rows leading up to the start of the slice).
  • search - Run a regex over CSV data. Applies the regex to each field individually and shows only matching rows.
  • table - Show aligned output of any CSV data using elastic tabstops.
  • flatten - A flattened view of CSV records. Useful for viewing one record at a time.

Newsbewertung

Weiterlesen

HPR2697: The Linux Shutdown Command Explained

Podcasts vom 04.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

A short podcast about the shutdown command

https://linuxhandbook.com/linux-shutdown-command/


Newsbewertung

Weiterlesen

HPR2697: The Linux Shutdown Command Explained

Podcasts vom 04.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

A short podcast about the shutdown command

https://linuxhandbook.com/linux-shutdown-command/


Newsbewertung

Weiterlesen

HPR2696: HPR Community News for November 2018

Podcasts vom 03.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

New hosts

Welcome to our new host:
desearcher.

Last Month's Shows

Id Day Date Title Host
2674 Thu 2018-11-01 Raspberry pi3 open media server JWP
2675 Fri 2018-11-02 YouTube Playlists Ahuka
2676 Mon 2018-11-05 HPR Community News for October 2018 HPR Volunteers
2677 Tue 2018-11-06 Thoughts on language learning part 4 - RPG. dodddummy
2678 Wed 2018-11-07 Explaining the controls on my Amateur HF Radio Part 4 MrX
2679 Thu 2018-11-08 Extra ancillary Bash tips - 13 Dave Morriss
2680 Fri 2018-11-09 Some Additional Talk About Characters -- 01 lostnbronx
2681 Mon 2018-11-12 DerbyCon Interview - Hackers for Charity Xoke
2682 Tue 2018-11-13 (NOT) All About Blender m1rr0r5h4d35
2683 Wed 2018-11-14 Using Open source tools to visualize the heartrate and blood oxygen saturation level of my stepchild Jeroen Baten
2684 Thu 2018-11-15 Making a remote control visible Ken Fallon
2685 Fri 2018-11-16 Scientific and Medical Reports Ahuka
2686 Mon 2018-11-19 (NOT) All About Blender - Part the Second m1rr0r5h4d35
2687 Tue 2018-11-20 Some Additional Talk About Characters -- 02 lostnbronx
2688 Wed 2018-11-21 Explaining the controls on my Amateur HF Radio Part 5 MrX
2689 Thu 2018-11-22 Bash Tips - 14 Dave Morriss
2690 Fri 2018-11-23 A chat about the HiveMQ Broker Ken Fallon
2691 Mon 2018-11-26 DerbyCon Interview - John Strand Xoke
2692 Tue 2018-11-27 YouTube URL tricks desearcher
2693 Wed 2018-11-28 Getting started with web based game in Haskell and Elm tuturto
2694 Thu 2018-11-29 Bandit Update NYbill
2695 Fri 2018-11-30 Problems with Studies Ahuka

Comments this month

These are comments which have been made during the past month, either to shows released during the month or to past shows.
There are 24 comments in total.

There are 9 comments on 7 previous shows:

  • hpr2399 (2017-10-12) "Using Super Glue to create Landmarks on Keyboards" by dodddummy.
    • Comment 8: dodddummy on 2018-11-23: "There's nothing new under the sun."

  • hpr2558 (2018-05-23) "Battling with English - part 1" by Dave Morriss.
    • Comment 7: FiftyOneFifty on 2018-11-05: "You missed one"
    • Comment 8: Dave Morriss on 2018-11-10: "Re: You missed one"

  • hpr2562 (2018-05-29) "I bought a laptop" by clacke.
    • Comment 2: FiftyOneFifty on 2018-11-05: "Getting paid in Cryptocurrency"

  • hpr2629 (2018-08-30) "Thoughts on language learning part 3 - game/story mode." by dodddummy.
    • Comment 1: Joel H. on 2018-10-31: "Good ideas!"

  • hpr2665 (2018-10-19) "Exercise and Diet" by Ahuka.
    • Comment 1: dodddummy on 2018-11-21: "You've convinced me."
    • Comment 2: Kevin O'Brien on 2018-11-28: "It is about making a decision"

  • hpr2668 (2018-10-24) "Explaining the controls on my Amateur HF Radio Part 3" by MrX.
    • Comment 2: lostnbronx on 2018-11-01: "Great Gear!"

  • hpr2672 (2018-10-30) "Porteus" by klaatu.
    • Comment 1: Alison Chaiken on 2018-11-11: "particularly informative episode"

There are 15 comments on 8 of this month's shows:

  • hpr2674 (2018-11-01) "Raspberry pi3 open media server" by JWP.
    • Comment 1: Jason Lewis on 2018-11-01: "Volume"

  • hpr2675 (2018-11-02) "YouTube Playlists" by Ahuka.

  • hpr2676 (2018-11-05) "HPR Community News for October 2018" by HPR Volunteers.
    • Comment 1: Ahuka on 2018-11-05: "What were you going to say?"
    • Comment 2: dodddummy on 2018-11-07: "Smiling all the way to the end."
    • Comment 3: dodddummy on 2018-11-07: "Ken's perfect example."
    • Comment 4: Ken Fallon on 2018-11-22: "we'll get back to that"

  • hpr2677 (2018-11-06) "Thoughts on language learning part 4 - RPG." by dodddummy.
    • Comment 1: dodddummy on 2018-10-22: "Looks like I forgot to tuncate silence"

  • hpr2679 (2018-11-08) "Extra ancillary Bash tips - 13" by Dave Morriss.
    • Comment 1: clacke on 2018-11-24: "Immediately useful"
    • Comment 2: Dave Morriss on 2018-11-25: "Thanks clacke!"

  • hpr2683 (2018-11-14) "Using Open source tools to visualize the heartrate and blood oxygen saturation level of my stepchild" by Jeroen Baten.
    • Comment 1: Ken Fallon on 2018-11-15: "Super Dad"
    • Comment 2: Clinton Roy on 2018-11-17: "Thank you."

  • hpr2684 (2018-11-15) "Making a remote control visible" by Ken Fallon.
    • Comment 1: ClaudioM on 2018-11-15: "LOL!"
    • Comment 2: pauleb on 2018-11-16: "Great hack, great episode!!"

  • hpr2693 (2018-11-28) "Getting started with web based game in Haskell and Elm" by tuturto.
    • Comment 1: klaatu on 2018-11-30: "Cool game idea, cool intro"

Mailing List discussions

Policy decisions surrounding HPR are taken by the community as a whole. This discussion takes place on the Mail List which is open to all HPR listeners and contributors. The discussions are open and available on the HPR server under Mailman.

The threaded discussions this month can be found here:

http://hackerpublicradio.org/pipermail/hpr_hackerpublicradio.org/2018-November/thread.html

Any other business

Hacker Public Radio New Year’s Eve Show

Edited from linuxlugcast.com

Hey folks

It’s that time of year again. Time for the Hacker Public Radio 24 hr (26 hr) New Years Eve Show.

For those who don’t know on New Years Eve 2018-12-31 at 10:00 am UTC (5:00 am EST) we will have a recording going on the HPR Mumble server (at ch1.teamspeak.cc on port 64747) for anyone to come on say “Happy New Year” and talk about what ever they want.

We will leave the recording going until 2019-01-01 12:00 am UTC (7:00 am EST) or until the conversation stops.

For those who have never used Mumble before, we have a guide over at linuxlugcast.com in our how to section explaining how to setup the desktop Mumble client, but Mumble isn’t only available for the desktop. It is also available for Android and IOS.

We are also going to setup an etherpad for people to share links to things they are discussing.

So please stop in. Say “Hi” and maybe join in the conversation with other HPR listeners and contributors. It’s always a good time.

New podcast - Libre Lounge

Libre Lounge

Quoted from the site:

Libre Lounge is a podcast where we casually discuss various topics involving user freedom, crossing free software, free culture, network and hosting freedom, and libre hardware designs. We discuss everything from policy and licensing to deep dives on technical topics… whatever seems interesting that week. At some point we might even have guests!

Internet Archive funding drive

As you know, HPR uploads all current episodes to the Internet Archive at http://archive.org, and is in the process of uploading older shows, so we are particularly keen that this amazing service continues.

The Internet Archive is currently fundraising. Donations are currently being matched by a generous supporter, so this will double your impact if you are able to donate.

Tags and Summaries

Over the period tags and/or summaries have been added to 23 shows which were without them.

If you would like to contribute to the tag/summary project visit the summary page at https://hackerpublicradio.org/report_missing_tags.php and follow the instructions there.


Newsbewertung

Weiterlesen

HPR2696: HPR Community News for November 2018

Podcasts vom 03.12.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

New hosts

Welcome to our new host:
desearcher.

Last Month's Shows

Id Day Date Title Host
2674 Thu 2018-11-01 Raspberry pi3 open media server JWP
2675 Fri 2018-11-02 YouTube Playlists Ahuka
2676 Mon 2018-11-05 HPR Community News for October 2018 HPR Volunteers
2677 Tue 2018-11-06 Thoughts on language learning part 4 - RPG. dodddummy
2678 Wed 2018-11-07 Explaining the controls on my Amateur HF Radio Part 4 MrX
2679 Thu 2018-11-08 Extra ancillary Bash tips - 13 Dave Morriss
2680 Fri 2018-11-09 Some Additional Talk About Characters -- 01 lostnbronx
2681 Mon 2018-11-12 DerbyCon Interview - Hackers for Charity Xoke
2682 Tue 2018-11-13 (NOT) All About Blender m1rr0r5h4d35
2683 Wed 2018-11-14 Using Open source tools to visualize the heartrate and blood oxygen saturation level of my stepchild Jeroen Baten
2684 Thu 2018-11-15 Making a remote control visible Ken Fallon
2685 Fri 2018-11-16 Scientific and Medical Reports Ahuka
2686 Mon 2018-11-19 (NOT) All About Blender - Part the Second m1rr0r5h4d35
2687 Tue 2018-11-20 Some Additional Talk About Characters -- 02 lostnbronx
2688 Wed 2018-11-21 Explaining the controls on my Amateur HF Radio Part 5 MrX
2689 Thu 2018-11-22 Bash Tips - 14 Dave Morriss
2690 Fri 2018-11-23 A chat about the HiveMQ Broker Ken Fallon
2691 Mon 2018-11-26 DerbyCon Interview - John Strand Xoke
2692 Tue 2018-11-27 YouTube URL tricks desearcher
2693 Wed 2018-11-28 Getting started with web based game in Haskell and Elm tuturto
2694 Thu 2018-11-29 Bandit Update NYbill
2695 Fri 2018-11-30 Problems with Studies Ahuka

Comments this month

These are comments which have been made during the past month, either to shows released during the month or to past shows.
There are 24 comments in total.

There are 9 comments on 7 previous shows:

  • hpr2399 (2017-10-12) "Using Super Glue to create Landmarks on Keyboards" by dodddummy.
    • Comment 8: dodddummy on 2018-11-23: "There's nothing new under the sun."

  • hpr2558 (2018-05-23) "Battling with English - part 1" by Dave Morriss.
    • Comment 7: FiftyOneFifty on 2018-11-05: "You missed one"
    • Comment 8: Dave Morriss on 2018-11-10: "Re: You missed one"

  • hpr2562 (2018-05-29) "I bought a laptop" by clacke.
    • Comment 2: FiftyOneFifty on 2018-11-05: "Getting paid in Cryptocurrency"

  • hpr2629 (2018-08-30) "Thoughts on language learning part 3 - game/story mode." by dodddummy.
    • Comment 1: Joel H. on 2018-10-31: "Good ideas!"

  • hpr2665 (2018-10-19) "Exercise and Diet" by Ahuka.
    • Comment 1: dodddummy on 2018-11-21: "You've convinced me."
    • Comment 2: Kevin O'Brien on 2018-11-28: "It is about making a decision"

  • hpr2668 (2018-10-24) "Explaining the controls on my Amateur HF Radio Part 3" by MrX.
    • Comment 2: lostnbronx on 2018-11-01: "Great Gear!"

  • hpr2672 (2018-10-30) "Porteus" by klaatu.
    • Comment 1: Alison Chaiken on 2018-11-11: "particularly informative episode"

There are 15 comments on 8 of this month's shows:

  • hpr2674 (2018-11-01) "Raspberry pi3 open media server" by JWP.
    • Comment 1: Jason Lewis on 2018-11-01: "Volume"

  • hpr2675 (2018-11-02) "YouTube Playlists" by Ahuka.

  • hpr2676 (2018-11-05) "HPR Community News for October 2018" by HPR Volunteers.
    • Comment 1: Ahuka on 2018-11-05: "What were you going to say?"
    • Comment 2: dodddummy on 2018-11-07: "Smiling all the way to the end."
    • Comment 3: dodddummy on 2018-11-07: "Ken's perfect example."
    • Comment 4: Ken Fallon on 2018-11-22: "we'll get back to that"

  • hpr2677 (2018-11-06) "Thoughts on language learning part 4 - RPG." by dodddummy.
    • Comment 1: dodddummy on 2018-10-22: "Looks like I forgot to tuncate silence"

  • hpr2679 (2018-11-08) "Extra ancillary Bash tips - 13" by Dave Morriss.
    • Comment 1: clacke on 2018-11-24: "Immediately useful"
    • Comment 2: Dave Morriss on 2018-11-25: "Thanks clacke!"

  • hpr2683 (2018-11-14) "Using Open source tools to visualize the heartrate and blood oxygen saturation level of my stepchild" by Jeroen Baten.
    • Comment 1: Ken Fallon on 2018-11-15: "Super Dad"
    • Comment 2: Clinton Roy on 2018-11-17: "Thank you."

  • hpr2684 (2018-11-15) "Making a remote control visible" by Ken Fallon.
    • Comment 1: ClaudioM on 2018-11-15: "LOL!"
    • Comment 2: pauleb on 2018-11-16: "Great hack, great episode!!"

  • hpr2693 (2018-11-28) "Getting started with web based game in Haskell and Elm" by tuturto.
    • Comment 1: klaatu on 2018-11-30: "Cool game idea, cool intro"

Mailing List discussions

Policy decisions surrounding HPR are taken by the community as a whole. This discussion takes place on the Mail List which is open to all HPR listeners and contributors. The discussions are open and available on the HPR server under Mailman.

The threaded discussions this month can be found here:

http://hackerpublicradio.org/pipermail/hpr_hackerpublicradio.org/2018-November/thread.html

Any other business

Hacker Public Radio New Year’s Eve Show

Edited from linuxlugcast.com

Hey folks

It’s that time of year again. Time for the Hacker Public Radio 24 hr (26 hr) New Years Eve Show.

For those who don’t know on New Years Eve 2018-12-31 at 10:00 am UTC (5:00 am EST) we will have a recording going on the HPR Mumble server (at ch1.teamspeak.cc on port 64747) for anyone to come on say “Happy New Year” and talk about what ever they want.

We will leave the recording going until 2019-01-01 12:00 am UTC (7:00 am EST) or until the conversation stops.

For those who have never used Mumble before, we have a guide over at linuxlugcast.com in our how to section explaining how to setup the desktop Mumble client, but Mumble isn’t only available for the desktop. It is also available for Android and IOS.

We are also going to setup an etherpad for people to share links to things they are discussing.

So please stop in. Say “Hi” and maybe join in the conversation with other HPR listeners and contributors. It’s always a good time.

New podcast - Libre Lounge

Libre Lounge

Quoted from the site:

Libre Lounge is a podcast where we casually discuss various topics involving user freedom, crossing free software, free culture, network and hosting freedom, and libre hardware designs. We discuss everything from policy and licensing to deep dives on technical topics… whatever seems interesting that week. At some point we might even have guests!

Internet Archive funding drive

As you know, HPR uploads all current episodes to the Internet Archive at http://archive.org, and is in the process of uploading older shows, so we are particularly keen that this amazing service continues.

The Internet Archive is currently fundraising. Donations are currently being matched by a generous supporter, so this will double your impact if you are able to donate.

Tags and Summaries

Over the period tags and/or summaries have been added to 23 shows which were without them.

If you would like to contribute to the tag/summary project visit the summary page at https://hackerpublicradio.org/report_missing_tags.php and follow the instructions there.


Newsbewertung

Weiterlesen

HPR2695: Problems with Studies

Podcasts vom 30.11.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

All medical studies are not alike. Some are of higher quality than others, and the conclusions they reach need to be evaluated based on some principles of good research. Here we take a look at some warning signs of bad or unreliable studies.


Newsbewertung

Weiterlesen

HPR2694: Bandit Update

Podcasts vom 29.11.2018 um 01:00 Uhr | Quelle hackerpublicradio.org

(No Spoilers)

NYbill does a quick episode to mention there are new Over the Wire, Bandit levels out.

http://overthewire.org/wargames/bandit/bandit0.html

Original Episode:

http://hackerpublicradio.org/eps.php?id=2138


Newsbewertung

Weiterlesen

Seitennavigation

Seite 1 von 2 Seiten (Bei Beitrag 1 - 35)
37x Beiträge in dieser Kategorie

Nächste 2 Seite | Letzte Seite
[ 2 ]