R E D

NAME	SIZE	PERMISSION
ModemManager	2.09 MB	-rwxr-xr-x
a2disconf	15.89 KB	-rwxr-xr-x
a2dismod	15.89 KB	-rwxr-xr-x
a2dissite	15.89 KB	-rwxr-xr-x
a2enconf	15.89 KB	-rwxr-xr-x
a2enmod	15.89 KB	-rwxr-xr-x
a2ensite	15.89 KB	-rwxr-xr-x
a2query	9.64 KB	-rwxr-xr-x
aa-remove-unknown	3 KB	-rwxr-xr-x
aa-status	62.62 KB	-rwxr-xr-x
aa-teardown	137 B	-rwxr-xr-x
accessdb	14.55 KB	-rwxr-xr-x
add-shell	1.03 KB	-rwxr-xr-x
addgnupghome	3 KB	-rwxr-xr-x
addgroup	37.35 KB	-rwxr-xr-x
adduser	37.35 KB	-rwxr-xr-x
agetty	55.56 KB	-rwxr-xr-x
apache2	740.89 KB	-rwxr-xr-x
apache2ctl	7.06 KB	-rwxr-xr-x
apachectl	7.06 KB	-rwxr-xr-x
apparmor_parser	1.48 MB	-rwxr-xr-x
apparmor_status	62.62 KB	-rwxr-xr-x
applygnupgdefaults	2.17 KB	-rwxr-xr-x
arp	61.61 KB	-rwxr-xr-x
arpd	26.33 KB	-rwxr-xr-x
arptables	219.04 KB	-rwxr-xr-x
arptables-nft	219.04 KB	-rwxr-xr-x
arptables-nft-restore	219.04 KB	-rwxr-xr-x
arptables-nft-save	219.04 KB	-rwxr-xr-x
arptables-restore	219.04 KB	-rwxr-xr-x
arptables-save	219.04 KB	-rwxr-xr-x
auth-otp	18.54 KB	-rwxr-xr-x
badblocks	34.32 KB	-rwxr-xr-x
bcache-super-show	14.3 KB	-rwxr-xr-x
biosdecode	23.2 KB	-rwxr-xr-x
blkdeactivate	15.97 KB	-rwxr-xr-x
blkdiscard	22.38 KB	-rwxr-xr-x
blkid	50.41 KB	-rwxr-xr-x
blkzone	34.38 KB	-rwxr-xr-x
blockdev	30.38 KB	-rwxr-xr-x
bridge	92.49 KB	-rwxr-xr-x
cache_check	1.33 MB	-rwxr-xr-x
cache_dump	1.33 MB	-rwxr-xr-x
cache_metadata_size	1.33 MB	-rwxr-xr-x
cache_repair	1.33 MB	-rwxr-xr-x
cache_restore	1.33 MB	-rwxr-xr-x
cache_writeback	1.33 MB	-rwxr-xr-x
capsh	30.3 KB	-rwxr-xr-x
cfdisk	94.73 KB	-rwxr-xr-x
cgdisk	150.48 KB	-rwxr-xr-x
chcpu	30.38 KB	-rwxr-xr-x
check_forensic	952 B	-rwxr-xr-x
chgpasswd	58.13 KB	-rwxr-xr-x
chmem	34.38 KB	-rwxr-xr-x
chpasswd	54.16 KB	-rwxr-xr-x
chroot	38.51 KB	-rwxr-xr-x
convertquota	66.88 KB	-rwxr-xr-x
cpgr	48.29 KB	-rwxr-xr-x
cppw	48.29 KB	-rwxr-xr-x
cron	50.58 KB	-rwxr-xr-x
cryptdisks_start	1.51 KB	-rwxr-xr-x
cryptdisks_stop	844 B	-rwxr-xr-x
cryptsetup	169.55 KB	-rwxr-xr-x
cryptsetup-reencrypt	90.38 KB	-rwxr-xr-x
cryptsetup-ssh	23.53 KB	-rwxr-xr-x
ctrlaltdel	14.38 KB	-rwxr-xr-x
dbconfig-generate-include	12.36 KB	-rwxr-xr-x
dbconfig-load-include	5.57 KB	-rwxr-xr-x
dcb	80.52 KB	-rwxr-xr-x
debugfs	229.8 KB	-rwxr-xr-x
delgroup	16.11 KB	-rwxr-xr-x
deluser	16.11 KB	-rwxr-xr-x
depmod	166.36 KB	-rwxr-xr-x
devlink	142.86 KB	-rwxr-xr-x
dhclient	442.66 KB	-rwxr-xr-x
dhclient-script	15.92 KB	-rwxr-xr-x
dmeventd	50.38 KB	-rwxr-xr-x
dmidecode	122.98 KB	-rwxr-xr-x
dmsetup	171.02 KB	-rwxr-xr-x
dmstats	171.02 KB	-rwxr-xr-x
dosfsck	82.38 KB	-rwxr-xr-x
dosfslabel	38.38 KB	-rwxr-xr-x
dpkg-preconfigure	3.58 KB	-rwxr-xr-x
dpkg-reconfigure	4.38 KB	-rwxr-xr-x
dumpe2fs	30.31 KB	-rwxr-xr-x
e2freefrag	14.3 KB	-rwxr-xr-x
e2fsck	351.84 KB	-rwxr-xr-x
e2image	42.31 KB	-rwxr-xr-x
e2label	102.55 KB	-rwxr-xr-x
e2mmpstatus	30.31 KB	-rwxr-xr-x
e2scrub	7.13 KB	-rwxr-xr-x
e2scrub_all	5.27 KB	-rwxr-xr-x
e2undo	22.3 KB	-rwxr-xr-x
e4crypt	30.38 KB	-rwxr-xr-x
e4defrag	30.3 KB	-rwxr-xr-x
ebtables	219.04 KB	-rwxr-xr-x
ebtables-nft	219.04 KB	-rwxr-xr-x
ebtables-nft-restore	219.04 KB	-rwxr-xr-x
ebtables-nft-save	219.04 KB	-rwxr-xr-x
ebtables-restore	219.04 KB	-rwxr-xr-x
ebtables-save	219.04 KB	-rwxr-xr-x
edquota	83.31 KB	-rwxr-xr-x
era_check	1.33 MB	-rwxr-xr-x
era_dump	1.33 MB	-rwxr-xr-x
era_invalidate	1.33 MB	-rwxr-xr-x
era_restore	1.33 MB	-rwxr-xr-x
ethtool	551.48 KB	-rwxr-xr-x
faillock	14.15 KB	-rwxr-xr-x
fatlabel	38.38 KB	-rwxr-xr-x
fdisk	110.42 KB	-rwxr-xr-x
filefrag	18.32 KB	-rwxr-xr-x
findfs	14.38 KB	-rwxr-xr-x
fixparts	58.48 KB	-rwxr-xr-x
fsadm	23.94 KB	-rwxr-xr-x
fsck	42.42 KB	-rwxr-xr-x
fsck.btrfs	1.16 KB	-rwxr-xr-x
fsck.cramfs	30.44 KB	-rwxr-xr-x
fsck.ext2	351.84 KB	-rwxr-xr-x
fsck.ext3	351.84 KB	-rwxr-xr-x
fsck.ext4	351.84 KB	-rwxr-xr-x
fsck.fat	82.38 KB	-rwxr-xr-x
fsck.minix	54.41 KB	-rwxr-xr-x
fsck.msdos	82.38 KB	-rwxr-xr-x
fsck.vfat	82.38 KB	-rwxr-xr-x
fsck.xfs	1.89 KB	-rwxr-xr-x
fsfreeze	14.38 KB	-rwxr-xr-x
fstab-decode	18.3 KB	-rwxr-xr-x
fstrim	42.38 KB	-rwxr-xr-x
ftpasswd	37.11 KB	-rwxr-xr-x
ftpmail	13.63 KB	-rwxr-xr-x
ftpquota	32.2 KB	-rwxr-xr-x
ftpscrub	23.66 KB	-rwxr-xr-x
ftpshut	14.3 KB	-rwxr-xr-x
ftpstats	12.16 KB	-rwxr-xr-x
gdisk	174.48 KB	-rwxr-xr-x
genl	90.44 KB	-rwxr-xr-x
getcap	14.3 KB	-rwxr-xr-x
getpcaps	14.3 KB	-rwxr-xr-x
getty	55.56 KB	-rwxr-xr-x
groupadd	66.91 KB	-rwxr-xr-x
groupdel	62.73 KB	-rwxr-xr-x
groupmems	54.19 KB	-rwxr-xr-x
groupmod	66.82 KB	-rwxr-xr-x
grpck	58.13 KB	-rwxr-xr-x
grpconv	50.01 KB	-rwxr-xr-x
grpunconv	50.01 KB	-rwxr-xr-x
grub-install	1.15 MB	-rwxr-xr-x
grub-macbless	929.11 KB	-rwxr-xr-x
grub-mkconfig	8.6 KB	-rwxr-xr-x
grub-mkdevicemap	215.7 KB	-rwxr-xr-x
grub-probe	941.36 KB	-rwxr-xr-x
grub-reboot	4.73 KB	-rwxr-xr-x
grub-set-default	3.47 KB	-rwxr-xr-x
halt	1.06 MB	-rwxr-xr-x
hdparm	139.43 KB	-rwxr-xr-x
httxt2dbm	14.3 KB	-rwxr-xr-x
hwclock	50.5 KB	-rwxr-xr-x
iconvconfig	30.4 KB	-rwxr-xr-x
ifconfig	77.17 KB	-rwxr-xr-x
in.proftpd	1.17 MB	-rwxr-xr-x
init	1.76 MB	-rwxr-xr-x
insmod	166.36 KB	-rwxr-xr-x
installkernel	2.6 KB	-rwxr-xr-x
integritysetup	54.07 KB	-rwxr-xr-x
invoke-rc.d	16.12 KB	-rwxr-xr-x
ip	702.05 KB	-rwxr-xr-x
ip6tables	219.04 KB	-rwxr-xr-x
ip6tables-apply	6.89 KB	-rwxr-xr-x
ip6tables-legacy	96.95 KB	-rwxr-xr-x
ip6tables-legacy-restore	96.95 KB	-rwxr-xr-x
ip6tables-legacy-save	96.95 KB	-rwxr-xr-x
ip6tables-nft	219.04 KB	-rwxr-xr-x
ip6tables-nft-restore	219.04 KB	-rwxr-xr-x
ip6tables-nft-save	219.04 KB	-rwxr-xr-x
ip6tables-restore	219.04 KB	-rwxr-xr-x
ip6tables-restore-translate	219.04 KB	-rwxr-xr-x
ip6tables-save	219.04 KB	-rwxr-xr-x
ip6tables-translate	219.04 KB	-rwxr-xr-x
ipmaddr	18.3 KB	-rwxr-xr-x
iptables	219.04 KB	-rwxr-xr-x
iptables-apply	6.89 KB	-rwxr-xr-x
iptables-legacy	96.95 KB	-rwxr-xr-x
iptables-legacy-restore	96.95 KB	-rwxr-xr-x
iptables-legacy-save	96.95 KB	-rwxr-xr-x
iptables-nft	219.04 KB	-rwxr-xr-x
iptables-nft-restore	219.04 KB	-rwxr-xr-x
iptables-nft-save	219.04 KB	-rwxr-xr-x
iptables-restore	219.04 KB	-rwxr-xr-x
iptables-restore-translate	219.04 KB	-rwxr-xr-x
iptables-save	219.04 KB	-rwxr-xr-x
iptables-translate	219.04 KB	-rwxr-xr-x
iptunnel	18.3 KB	-rwxr-xr-x
irqbalance	66.86 KB	-rwxr-xr-x
irqbalance-ui	34.38 KB	-rwxr-xr-x
iscsi-iname	14.3 KB	-rwxr-xr-x
iscsi_discovery	5.17 KB	-rwxr-xr-x
iscsiadm	398.46 KB	-rwxr-xr-x
iscsid	298.55 KB	-rwxr-xr-x
iscsistart	278.56 KB	-rwxr-xr-x
isosize	14.38 KB	-rwxr-xr-x
iucode-tool	58.34 KB	-rwxr-xr-x
iucode_tool	58.34 KB	-rwxr-xr-x
kbdrate	18.16 KB	-rwxr-xr-x
killall5	30.38 KB	-rwxr-xr-x
kpartx	46.16 KB	-rwxr-xr-x
ldattach	26.38 KB	-rwxr-xr-x
ldconfig	387 B	-rwxr-xr-x
ldconfig.real	1.16 MB	-rwxr-xr-x
locale-gen	4.29 KB	-rwxr-xr-x
logrotate	102.24 KB	-rwxr-xr-x
logsave	14.16 KB	-rwxr-xr-x
losetup	70.52 KB	-rwxr-xr-x
lsmod	166.36 KB	-rwxr-xr-x
luksformat	3.32 KB	-rwxr-xr-x
lvchange	2.89 MB	-rwxr-xr-x
lvconvert	2.89 MB	-rwxr-xr-x
lvcreate	2.89 MB	-rwxr-xr-x
lvdisplay	2.89 MB	-rwxr-xr-x
lvextend	2.89 MB	-rwxr-xr-x
lvm	2.89 MB	-rwxr-xr-x
lvmconfig	2.89 MB	-rwxr-xr-x
lvmdiskscan	2.89 MB	-rwxr-xr-x
lvmdump	10.07 KB	-rwxr-xr-x
lvmpolld	236.2 KB	-rwxr-xr-x
lvmsadc	2.89 MB	-rwxr-xr-x
lvmsar	2.89 MB	-rwxr-xr-x
lvreduce	2.89 MB	-rwxr-xr-x
lvremove	2.89 MB	-rwxr-xr-x
lvrename	2.89 MB	-rwxr-xr-x
lvresize	2.89 MB	-rwxr-xr-x
lvs	2.89 MB	-rwxr-xr-x
lvscan	2.89 MB	-rwxr-xr-x
make-bcache	22.38 KB	-rwxr-xr-x
make-ssl-cert	6.65 KB	-rwxr-xr-x
mdadm	601.31 KB	-rwxr-xr-x
mdmon	258.44 KB	-rwxr-xr-x
mii-tool	26.73 KB	-rwxr-xr-x
mkdosfs	50.83 KB	-rwxr-xr-x
mke2fs	130.62 KB	-rwxr-xr-x
mkfs	14.38 KB	-rwxr-xr-x
mkfs.bfs	22.38 KB	-rwxr-xr-x
mkfs.btrfs	471.25 KB	-rwxr-xr-x
mkfs.cramfs	34.32 KB	-rwxr-xr-x
mkfs.ext2	130.62 KB	-rwxr-xr-x
mkfs.ext3	130.62 KB	-rwxr-xr-x
mkfs.ext4	130.62 KB	-rwxr-xr-x
mkfs.fat	50.83 KB	-rwxr-xr-x
mkfs.minix	42.39 KB	-rwxr-xr-x
mkfs.msdos	50.83 KB	-rwxr-xr-x
mkfs.ntfs	70.38 KB	-rwxr-xr-x
mkfs.vfat	50.83 KB	-rwxr-xr-x
mkfs.xfs	382.77 KB	-rwxr-xr-x
mkhomedir_helper	22.17 KB	-rwxr-xr-x
mkinitramfs	12.16 KB	-rwxr-xr-x
mklost+found	14.3 KB	-rwxr-xr-x
mkntfs	70.38 KB	-rwxr-xr-x
mkswap	46.38 KB	-rwxr-xr-x
modinfo	166.36 KB	-rwxr-xr-x
modprobe	166.36 KB	-rwxr-xr-x
mount.fuse	18.3 KB	-rwxr-xr-x
mount.fuse3	18.3 KB	-rwxr-xr-x
mount.lowntfs-3g	114.98 KB	-rwxr-xr-x
mount.ntfs	159.01 KB	-rwxr-xr-x
mount.ntfs-3g	159.01 KB	-rwxr-xr-x
mpathpersist	31.05 KB	-rwxr-xr-x
multipath	34.15 KB	-rwxr-xr-x
multipathd	134.26 KB	-rwxr-xr-x
mysqld	53.02 MB	-rwxr-xr-x
nameif	14.48 KB	-rwxr-xr-x
needrestart	38.73 KB	-rwxr-xr-x
netplan	798 B	-rwxr-xr-x
newusers	74.73 KB	-rwxr-xr-x
nfnl_osf	18.3 KB	-rwxr-xr-x
nft	26.23 KB	-rwxr-xr-x
nologin	14.3 KB	-rwxr-xr-x
ntfsclone	50.38 KB	-rwxr-xr-x
ntfscp	34.38 KB	-rwxr-xr-x
ntfslabel	22.38 KB	-rwxr-xr-x
ntfsresize	62.39 KB	-rwxr-xr-x
ntfsundelete	50.38 KB	-rwxr-xr-x
on_ac_power	3.7 KB	-rwxr-xr-x
overlayroot-chroot	2.45 KB	-rwxr-xr-x
ownership	14.45 KB	-rwxr-xr-x
pam-auth-update	20.5 KB	-rwxr-xr-x
pam_extrausers_chkpwd	22.15 KB	-rwxr-sr-x
pam_extrausers_update	30.15 KB	-rwxr-xr-x
pam_getenv	2.82 KB	-rwxr-xr-x
pam_timestamp_check	14.15 KB	-rwxr-xr-x
parted	86.4 KB	-rwxr-xr-x
partprobe	14.38 KB	-rwxr-xr-x
pdata_tools	1.33 MB	-rwxr-xr-x
phpdismod	7.11 KB	-rwxr-xr-x
phpenmod	7.11 KB	-rwxr-xr-x
phpquery	6.24 KB	-rwxr-xr-x
pivot_root	14.38 KB	-rwxr-xr-x
plipconfig	14.3 KB	-rwxr-xr-x
plymouthd	150.55 KB	-rwxr-xr-x
poweroff	1.06 MB	-rwxr-xr-x
proftpd	1.17 MB	-rwxr-xr-x
proftpd-gencert	1.64 KB	-rwxr-xr-x
pvchange	2.89 MB	-rwxr-xr-x
pvck	2.89 MB	-rwxr-xr-x
pvcreate	2.89 MB	-rwxr-xr-x
pvdisplay	2.89 MB	-rwxr-xr-x
pvmove	2.89 MB	-rwxr-xr-x
pvremove	2.89 MB	-rwxr-xr-x
pvresize	2.89 MB	-rwxr-xr-x
pvs	2.89 MB	-rwxr-xr-x
pvscan	2.89 MB	-rwxr-xr-x
pwck	50.13 KB	-rwxr-xr-x
pwconv	46.01 KB	-rwxr-xr-x
pwunconv	42.01 KB	-rwxr-xr-x
quota_nld	26.41 KB	-rwxr-xr-x
quotacheck	91.34 KB	-rwxr-xr-x
quotaoff	54.78 KB	-rwxr-xr-x
quotaon	54.78 KB	-rwxr-xr-x
quotastats	14.15 KB	-rwxr-xr-x
rarp	32.33 KB	-rwxr-xr-x
readprofile	22.41 KB	-rwxr-xr-x
reboot	1.06 MB	-rwxr-xr-x
remove-shell	1.07 KB	-rwxr-xr-x
repquota	71.41 KB	-rwxr-xr-x
resize2fs	66.3 KB	-rwxr-xr-x
rmmod	166.36 KB	-rwxr-xr-x
rmt	58.57 KB	-rwxr-xr-x
rmt-tar	58.57 KB	-rwxr-xr-x
route	64.27 KB	-rwxr-xr-x
rpc.rquotad	75.18 KB	-rwxr-xr-x
rsyslogd	767.19 KB	-rwxr-xr-x
rtacct	28.31 KB	-rwxr-xr-x
rtcwake	34.38 KB	-rwxr-xr-x
rtmon	90.39 KB	-rwxr-xr-x
runlevel	1.06 MB	-rwxr-xr-x
runuser	54.38 KB	-rwxr-xr-x
service	8.88 KB	-rwxr-xr-x
setcap	14.3 KB	-rwxr-xr-x
setquota	79.38 KB	-rwxr-xr-x
setvesablank	14.23 KB	-rwxr-xr-x
setvtrgb	14.29 KB	-rwxr-xr-x
sfdisk	102.38 KB	-rwxr-xr-x
sgdisk	162.48 KB	-rwxr-xr-x
shadowconfig	885 B	-rwxr-xr-x
shutdown	1.06 MB	-rwxr-xr-x
slattach	36.08 KB	-rwxr-xr-x
split-logfile	2.36 KB	-rwxr-xr-x
sshd	899.7 KB	-rwxr-xr-x
start-stop-daemon	47.35 KB	-rwxr-xr-x
sudo_logsrvd	200.1 KB	-rwxr-xr-x
sudo_sendlog	107.34 KB	-rwxr-xr-x
sulogin	42.38 KB	-rwxr-xr-x
swaplabel	18.38 KB	-rwxr-xr-x
swapoff	22.38 KB	-rwxr-xr-x
swapon	42.38 KB	-rwxr-xr-x
switch_root	22.38 KB	-rwxr-xr-x
sysctl	30.23 KB	-rwxr-xr-x
tarcat	936 B	-rwxr-xr-x
tc	614.08 KB	-rwxr-xr-x
telinit	1.06 MB	-rwxr-xr-x
thermald	554.6 KB	-rwxr-xr-x
thin_check	1.33 MB	-rwxr-xr-x
thin_delta	1.33 MB	-rwxr-xr-x
thin_dump	1.33 MB	-rwxr-xr-x
thin_ls	1.33 MB	-rwxr-xr-x
thin_metadata_size	1.33 MB	-rwxr-xr-x
thin_repair	1.33 MB	-rwxr-xr-x
thin_restore	1.33 MB	-rwxr-xr-x
thin_rmap	1.33 MB	-rwxr-xr-x
thin_trim	1.33 MB	-rwxr-xr-x
tipc	90.44 KB	-rwxr-xr-x
tune2fs	102.55 KB	-rwxr-xr-x
tzconfig	106 B	-rwxr-xr-x
u-d-c-print-pci-ids	517 B	-rwxr-xr-x
ufw	4.82 KB	-rwxr-xr-x
umount.udisks2	14.3 KB	-rwxr-xr-x
unix_chkpwd	26.15 KB	-rwxr-sr-x
unix_update	30.15 KB	-rwxr-xr-x
update-ca-certificates	5.29 KB	-rwxr-xr-x
update-grub	64 B	-rwxr-xr-x
update-grub2	64 B	-rwxr-xr-x
update-info-dir	1.66 KB	-rwxr-xr-x
update-initramfs	6.74 KB	-rwxr-xr-x
update-locale	2.99 KB	-rwxr-xr-x
update-mime	9.39 KB	-rwxr-xr-x
update-passwd	34.56 KB	-rwxr-xr-x
update-pciids	1.71 KB	-rwxr-xr-x
update-rc.d	16.92 KB	-rwxr-xr-x
update-secureboot-policy	7.43 KB	-rwxr-xr-x
update-shells	3.72 KB	-rwxr-xr-x
usb_modeswitch	59.66 KB	-rwxr-xr-x
usb_modeswitch_dispatcher	26.78 KB	-rwxr-xr-x
usbmuxd	86.6 KB	-rwxr-xr-x
useradd	127.66 KB	-rwxr-xr-x
userdel	86.85 KB	-rwxr-xr-x
usermod	123.46 KB	-rwxr-xr-x
uuidd	30.85 KB	-rwxr-xr-x
validlocale	1.73 KB	-rwxr-xr-x
vcstime	14.15 KB	-rwxr-xr-x
vdpa	30.56 KB	-rwxr-xr-x
veritysetup	43.76 KB	-rwxr-xr-x
vgcfgbackup	2.89 MB	-rwxr-xr-x
vgcfgrestore	2.89 MB	-rwxr-xr-x
vgchange	2.89 MB	-rwxr-xr-x
vgck	2.89 MB	-rwxr-xr-x
vgconvert	2.89 MB	-rwxr-xr-x
vgcreate	2.89 MB	-rwxr-xr-x
vgdisplay	2.89 MB	-rwxr-xr-x
vgexport	2.89 MB	-rwxr-xr-x
vgextend	2.89 MB	-rwxr-xr-x
vgimport	2.89 MB	-rwxr-xr-x
vgimportclone	2.89 MB	-rwxr-xr-x
vgmerge	2.89 MB	-rwxr-xr-x
vgmknodes	2.89 MB	-rwxr-xr-x
vgreduce	2.89 MB	-rwxr-xr-x
vgremove	2.89 MB	-rwxr-xr-x
vgrename	2.89 MB	-rwxr-xr-x
vgs	2.89 MB	-rwxr-xr-x
vgscan	2.89 MB	-rwxr-xr-x
vgsplit	2.89 MB	-rwxr-xr-x
vigr	56.53 KB	-rwxr-xr-x
vipw	56.53 KB	-rwxr-xr-x
visudo	219.79 KB	-rwxr-xr-x
vpddecode	14.58 KB	-rwxr-xr-x
warnquota	87.3 KB	-rwxr-xr-x
wipefs	38.38 KB	-rwxr-xr-x
xfs_admin	1.37 KB	-rwxr-xr-x
xfs_bmap	695 B	-rwxr-xr-x
xfs_copy	82.48 KB	-rwxr-xr-x
xfs_db	652.44 KB	-rwxr-xr-x
xfs_estimate	14.16 KB	-rwxr-xr-x
xfs_freeze	800 B	-rwxr-xr-x
xfs_fsr	42.18 KB	-rwxr-xr-x
xfs_growfs	38.28 KB	-rwxr-xr-x
xfs_info	1.26 KB	-rwxr-xr-x
xfs_io	199.55 KB	-rwxr-xr-x
xfs_logprint	78.33 KB	-rwxr-xr-x
xfs_mdrestore	26.17 KB	-rwxr-xr-x
xfs_metadump	782 B	-rwxr-xr-x
xfs_mkfile	1.02 KB	-rwxr-xr-x
xfs_ncheck	685 B	-rwxr-xr-x
xfs_quota	90.16 KB	-rwxr-xr-x
xfs_repair	599.38 KB	-rwxr-xr-x
xfs_rtcp	18.15 KB	-rwxr-xr-x
xfs_scrub	106.27 KB	-rwxr-xr-x
xfs_scrub_all	5.87 KB	-rwxr-xr-x
xfs_spaceman	42.3 KB	-rwxr-xr-x
xqmstats	14.15 KB	-rwxr-xr-x
xtables-legacy-multi	96.95 KB	-rwxr-xr-x
xtables-monitor	219.04 KB	-rwxr-xr-x
xtables-nft-multi	219.04 KB	-rwxr-xr-x
zerofree	14.15 KB	-rwxr-xr-x
zic	62.32 KB	-rwxr-xr-x
zramctl	54.52 KB	-rwxr-xr-x

Code Editor : ftpasswd

#!/usr/bin/perl
# ---------------------------------------------------------------------------
# Copyright (C) 2000-2020 TJ Saunders <tj@castaglia.org>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
#
# Based on MacGuyver's genuser.pl script, this script generates password
# files suitable for use with proftpd's AuthUserFile directive, in passwd(5)
# format, or AuthGroupFile, in group(5) format.  The idea is somewhat similar
# to Apache's htpasswd program.
# ---------------------------------------------------------------------------

use strict;

use Fcntl qw(:flock);
use File::Basename qw(basename);
use Getopt::Long;

# turn off auto abbreviation
$Getopt::Long::auto_abbrev = 0;

my $program = basename($0);
my $default_passwd_file = "./ftpd.passwd";
my $default_group_file = "./ftpd.group";
my $shell_file = "/etc/shells";
#my $default_cracklib_dict = "/usr/lib/cracklib_dict";
my $default_cracklib_dict = "/var/cache/cracklib";
my $cracklib_dict;
my $output_file;
my $version = "1.3.0";

my @data;

my %opts = ();
GetOptions(\%opts,
  'add-member=s',
  'change-home',
  'change-password',
  'delete-group',
  'delete-member=s',
  'delete-user',
  'des',
  'enable-group-passwd',
  'file=s',
  'F|force',
  'gecos=s',
  'gid=n',
  'group',
  'hash',
  'h|help',
  'home=s',
  'l|lock',
  'md5',
  'm|member=s@',
  'name=s',
  'not-previous-password',
  'not-system-password',
  'passwd',
  'sha256',
  'sha512',
  'shell=s',
  'stdin',
  'uid=n',
  'u|unlock',
  'use-cracklib:s',
  'version',
);

usage() if (defined($opts{'h'}));

version() if (defined($opts{'version'}));

# Per Bug#4171, check if we are on a Linux system, AND it has the
# /proc/sys/crypto/fips_enabled file, AND that entry says that FIPS mode is
# enabled.  If these conditions are met, then neither DES or MD5 will work.
#
# If either --des or --md5 are specified, OR if no hash is specified, we
# need to check.
if ((defined($opts{'des'}) || defined($opts{'md5'})) ||
     !defined($opts{'des'}) && !defined($opts{'md5'}) &&
     !defined($opts{'sha256'}) && !defined($opts{'sha512'})) {
  if (open(my $fh, "< /proc/sys/crypto/fips_enabled")) {
    my $fips_enabled = <$fh>;
    close($fh);

chomp($fips_enabled);
    if ($fips_enabled) {
      die "$program: FIPS mode enabled on your system (see /proc/sys/crypto/fips_enabled), thus --des and --md5 will not be supported.  Use --sha256 or --sha512.\n"
    }
  }
}

# check if "use-cracklib" was given as an option, and whether a path
# to other dictionary files was given.
if (defined($opts{'use-cracklib'})) {

# make sure that Crypt::Cracklib is installed before trying to use
  # it later
  eval { require Crypt::Cracklib };
  die "$program: --use-cracklib requires Crypt::Cracklib to be installed\n" if $@;

if ($opts{'use-cracklib'} ne "") {
    $cracklib_dict = $opts{'use-cracklib'};

} else {
    $cracklib_dict = $default_cracklib_dict;
  }
}

# Make sure that the given --home path exists, and is a directory.
if (exists($opts{'home'})) {
  my $path = $opts{'home'};
  unless (-e $path) {
    die "$program: --home $path does not exist\n";
  }

unless (-d $path) {
    die "$program: --home $path is not a directory\n";
  }
}

# make sure that both passwd and group modes haven't been simultaneously
# requested
if ((exists($opts{'passwd'}) && exists($opts{'group'})) ||
    (exists($opts{'passwd'}) && exists($opts{'hash'})) ||
    (exists($opts{'group'}) && exists($opts{'hash'}))) {
  die "$program: please use *one*: --passwd, --group, or --hash\n";

} elsif (defined($opts{'passwd'})) {

# determine to which file to write the passwd entry
  if (defined($opts{'file'})) {
    $output_file = $opts{'file'}; 
    print STDOUT "$program: using alternate file: $output_file\n"

} else {
    $output_file = $default_passwd_file;
  }

# make sure that the required arguments are present
  die "$program: --passwd: missing required argument: --name\n"
    unless (defined($opts{'name'}));

# check for and handle the --delete-user option.
  if (defined($opts{'delete-user'})) {
    open_output_file();

my ($pass, $uid, $gid, $gecos, $home, $shell) = find_passwd_entry(name =>
      $opts{'name'});

handle_passwd_entry(name => $opts{'name'}, uid => $uid, gid => $gid,
      gecos => $gecos, home => $home, shell => $shell,
      delete_user => $opts{'delete-user'});

close_output_file();

# done
    exit 0;
  }

# check for and handle the --lock option.
  if (defined($opts{'l'})) {
    open_output_file();

my ($pass, $uid, $gid, $gecos, $home, $shell) = find_passwd_entry(name =>
      $opts{'name'});

my $new_passwd = $pass;

# If this password is already "locked", leave it alone
    if ($new_passwd !~ /^!/) {
      $new_passwd = '!' . $new_passwd;
    }

handle_passwd_entry(name => $opts{'name'}, uid => $uid, gid => $gid,
      gecos => $gecos, home => $home, shell => $shell,
      new_passwd => $new_passwd);

close_output_file();

# done
    exit 0;
  }

# check for and handle the --unlock option.
  if (defined($opts{'u'})) {
    open_output_file();

my ($pass, $uid, $gid, $gecos, $home, $shell) = find_passwd_entry(name =>
      $opts{'name'});

my $new_passwd = $pass;
    $new_passwd =~ s/^!+//;

handle_passwd_entry(name => $opts{'name'}, uid => $uid, gid => $gid,
      gecos => $gecos, home => $home, shell => $shell,
      new_passwd => $new_passwd);

close_output_file();

# done
    exit 0;
  }

# now check for the --change-password option.  If present, lookup
  # the given name in the password file, and reuse all the information
  # except for the password
  if (defined($opts{'change-password'})) {
    open_output_file();

my ($pass, $uid, $gid, $gecos, $home, $shell) = find_passwd_entry(name =>
      $opts{'name'});

handle_passwd_entry(name => $opts{'name'}, uid => $uid, gid => $gid,
      gecos => $gecos, home => $home, shell => $shell);

close_output_file();

# done
    exit 0;
  }

# Now check for the --change-home option.  If present, lookup the given name
  # in the password file, and reuse all the information except for the home.
  if (defined($opts{'change-home'})) {
    if (!defined($opts{'home'})) {
      die "$program: --change-home requires use of --home\n";
    }

open_output_file();

my ($pass, $uid, $gid, $gecos, $home, $shell) = find_passwd_entry(name =>
      $opts{'name'});

# We trick this function into not prompting for a password by acting
    # as if we are handling a new password.
    handle_passwd_entry(name => $opts{'name'}, uid => $uid, gid => $gid,
      gecos => $gecos, home => $opts{'home'}, shell => $shell,
      new_passwd => $pass);

close_output_file();

# done
    exit 0;
  }

# check for the --not-system-password option.  If present, make sure that
  # a) the script is running with root privs, and b) perl on the system is
  # such that getpwnam() will return the system password
  if (defined($opts{'not-system-password'})) {
    die "$program: must be user root for system password check\n"
      unless ($> == 0);
  }

die "$program: --passwd: missing required argument: --home\n"
    unless (defined($opts{'home'}));

die "$program: --passwd: missing required argument: --shell\n"
    unless (defined($opts{'shell'}));

die "$program: --passwd: missing required argument: --uid\n"
    unless (defined($opts{'uid'}));

# As per Flying Hamster's suggestion, have $opts{'gid'} default to --uid
  # if none are specified on the command-line via --gid
  unless (defined($opts{'gid'})) {
    $opts{'gid'} = $opts{'uid'};
    warn "$program: --passwd: missing --gid argument: default gid set to uid\n";
  }

open_output_file();

handle_passwd_entry(name => $opts{'name'}, uid => $opts{'uid'},
    gid => $opts{'gid'}, gecos => $opts{'gecos'}, home => $opts{'home'},
    shell => $opts{'shell'}, delete_user => $opts{'delete-user'});

close_output_file();

# NOTE: if this process is not running as root, then the file generated
  # is not owned by root.  Issue a warning reminding the user to make the
  # generated file mode 0400, owned by root, before using it.

} elsif (defined($opts{'group'})) {

# determine to which file to write the group entry
  if (defined($opts{'file'})) {
    $output_file = $opts{'file'};
    print STDOUT "$program: using alternate file: $output_file\n";

} else {
    $output_file = $default_group_file;
  }

# check for and handle the --delete-group option.
  if (defined($opts{'delete-group'})) {
    open_output_file();

handle_group_entry(
      name => $opts{'name'},
      delete_group => $opts{'delete-group'}
    );

close_output_file();

# done
    exit 0;
  }

# make sure the required options are present
  if (!defined($opts{'add-member'}) &&
      !defined($opts{'delete-member'})) {
    die "$program: --group: missing required argument: --gid\n"
      unless (defined($opts{'gid'}));
  }

die "$program: --group: missing required argument: --name\n"
    unless (defined($opts{'name'}));

open_output_file();

handle_group_entry(
    gid => $opts{'gid'},
    members => $opts{'m'},
    name => $opts{'name'},
    add_user => $opts{'add-member'},
    delete_group => $opts{'delete-group'},
    delete_user => $opts{'delete-member'}
  );

close_output_file();

} elsif (defined($opts{'hash'})) {
  print STDOUT "$program: ", get_passwd(), "\n";

} else {
  die "$program: missing required --passwd or --group\n$program: use $program --help for details on usage\n\n";
}

# done
exit 0;

# ----------------------------------------------------------------------------
sub check_shell {
  my %args = @_;

my $shell = $args{'shell'};
  my $result = 0;

# check the given shell against the list in /etc/shells.  If not present
  # there, issue a message recognizing this, and suggesting that
  # RequireValidShell be set to off, and that any necessary PAM modules be
  # adjusted.

unless (open(SHELLS, "< $shell_file")) {
    warn "$program: unable to open $shell_file: $!\n";
    warn "$program: skipping check of $shell_file\n";
    return;
  }

while(my $line = <SHELLS>) {
    chomp($line);

if ($line eq $shell) {
      $result = 1;
      last;
    } 
  }

close(SHELLS);

unless ($result) {
    print STDOUT "\n$program: $shell is not among the valid system shells.  Use of\n";
    print STDOUT "$program: \"RequireValidShell off\" may be required, and the PAM\n";
    print STDOUT "$program: module configuration may need to be adjusted.\n\n";
  }

return $result;
}

# ----------------------------------------------------------------------------
sub close_output_file {
  my %args = @_;

if (open(my $fh, "> $output_file")) {
    if (flock($fh, LOCK_EX|LOCK_NB)) {
      # flush the data to the file
      foreach my $line (@data) {
        print $fh "$line\n";
      }

# set the permissions appropriately, ie 0440, before closing the file
      unless (chmod(0440, $output_file)) {
        flock($fh, LOCK_UN);
        die("$program: unable to set permissions on $output_file: $!");
      }

flock($fh, LOCK_UN);

unless (close($fh)) {
        die("$program: unable to close $output_file: $!\n");
      }

} else {
      close($fh);
      die("$program: unable to write $output_file: Locked (in use) by another process\n");
    }

} else {
    die("$program: unable to open $output_file: $!\n");
  }
}

# ----------------------------------------------------------------------------
sub find_passwd_entry {
  my %args = @_;

my $name = $args{'name'};
  my ($pass, $uid, $gid, $gecos, $home, $shell);
  my $found = 0;

# given a name, find the corresponding entry in the passwd file
  foreach my $line (@data) {
    next unless $line =~ /^$name:/;

my @fields = split(':', $line);

$pass = $fields[1];
    $uid = $fields[2];
    $gid = $fields[3];
    $gecos = $fields[4];
    $home = $fields[5];
    $shell = $fields[6];

$found = 1;

last;
  }

unless ($found) {
    print STDOUT "$program: error: no such user $name in $output_file\n";

# Restore the file permissions.
    unless (chmod(0440, $output_file)) {
      print STDERR "$program: unable to set permissions on $output_file: $!";
    }

exit 1;
  }

return ($pass, $uid, $gid, $gecos, $home, $shell);
}

# ----------------------------------------------------------------------------
sub get_salt {
  my $salt;

# The determination of with encryption algorithm to use is done via
  # the salt.  The format and nature of the salt is how crypt(3) knows
  # how to do its thing.  By default, generate a salt that triggers MD5.

if (defined($opts{'des'})) {
    # DES salt
    $salt = join '', ('.', '/', 0..9, 'A'..'Z', 'a'..'z')[rand 64, rand 64];

} elsif (defined($opts{'sha256'})) {
    # SHA-256 salt (16 characters)
    $salt = join '', (0..9, 'A'..'Z', 'a'..'z')
      [rand 62, rand 62, rand 62, rand 62,
       rand 62, rand 62, rand 62, rand 62,
       rand 62, rand 62, rand 62, rand 62,
       rand 62, rand 62, rand 62, rand 62];
    $salt = '$5$' . $salt;

} elsif (defined($opts{'sha512'})) {
    # SHA-512 salt (16 characters)
    $salt = join '', (0..9, 'A'..'Z', 'a'..'z')
      [rand 62, rand 62, rand 62, rand 62,
       rand 62, rand 62, rand 62, rand 62,
       rand 62, rand 62, rand 62, rand 62,
       rand 62, rand 62, rand 62, rand 62];
    $salt = '$6$' . $salt;

} else {
    # MD5 salt (16 characters)
    $salt = join '', (0..9, 'A'..'Z', 'a'..'z')
      [rand 62, rand 62, rand 62, rand 62,
       rand 62, rand 62, rand 62, rand 62,
       rand 62, rand 62, rand 62, rand 62,
       rand 62, rand 62, rand 62, rand 62];
    $salt = '$1$' . $salt;
  }

return $salt;
}

# ----------------------------------------------------------------------------
sub get_passwd {
  my %args = @_;
  my $name = $args{'name'};
  my ($passwd, $passwd2);

# If using a DES salt, print an informative message about the 8 character
  # limit of relevant password characters.

if (defined($opts{'des'}) && !defined($opts{'stdin'})) {
    print STDOUT "\nPlease be aware that only the first 8 characters of a DES password are\nrelevant.  Use the --md5, --sha256, or --sha512 options as they do not have\nthis limitation.\n";
  }

if (defined($opts{'stdin'})) {

# simply read in the password from stdin, as from a script
    chomp($passwd = <STDIN>);

} else {

# Install a SIGINT handler, for cases where Ctrl-C may be used to abort
    # the prompt.
    $SIG{INT} = sub {
      # Restore the file permissions.
      unless (chmod(0440, $output_file)) {
        print STDERR "$program: unable to set permissions on $output_file: $!";
      }

# Restore the terminal echo behavior, too.
      system "stty echo";

exit 1;
    };

# Prompt for the password to be used
    system "stty -echo";
    print STDOUT "\nPassword: ";

# Open the tty for reading (is this portable?)
    open(TTY, "/dev/tty") or die "$program: unable to open /dev/tty: $!\n";
    chomp($passwd = <TTY>);
    print STDOUT "\n";
    system "stty echo";

# Prompt again, to make sure the user typed in the password correctly
    system "stty -echo";
    print STDOUT "Re-type password: ";
    chomp($passwd2 = <TTY>);
    print STDOUT "\n\n";
    system "stty echo";
    close(TTY);

# Restore default SIGINT handling
    $SIG{INT} = 'DEFAULT';

if ($passwd2 ne $passwd) {
      print STDOUT "Passwords do not match.  Please try again.\n";
      return get_passwd(name => $name);
    }
  }

if (defined($name) && defined($opts{'change-password'})) {

# retrieve the user's current password from the file and compare
    my ($curpasswd, @junk) = find_passwd_entry(name => $name);

my $hash = crypt($passwd, $curpasswd);

if ($hash eq $curpasswd) {
      if (defined($opts{'stdin'})) {
        # cannot prompt again if automated.  Simply print an error message
        # and exit.
        print STDOUT "$program: error: password matches current password\n";

# Restore the file permissions.
        unless (chmod(0440, $output_file)) {
          print STDERR "$program: unable to set permissions on $output_file: $!";
        }

exit 2;

} else {
        print STDOUT "Please use a password that is different from your current password.\n";
        return get_passwd(name => $name);
      }
    }
  }

if (defined($name) && defined($opts{'not-previous-password'})) {
    # retrieve the user's current passwd and compare
    my ($currpasswd) = find_passwd_entry(name => $name);

my $hash = crypt($passwd, $currpasswd);

if (($hash && $currpasswd) && $hash eq $currpasswd) {
      if (defined($opts{'stdin'})) {

# cannot prompt again if automated.  Simply print an error message
        # and exit.
        print STDOUT "$program: error: password matches previous password\n";

# Restore the file permissions.
        unless (chmod(0440, $output_file)) {
          print STDERR "$program: unable to set permissions on $output_file: $!";
        }

exit 4;

} else {
        print STDOUT "Please use a password that is different from your previous password.\n";
        return get_passwd(name => $name);
      }
    }
  }

if (defined($name) && defined($opts{'not-system-password'})) {
    # retrieve the user's system passwd (from /etc/shadow) and compare
    my $syspasswd = get_syspasswd(user => $name);

my $hash = crypt($passwd, $syspasswd);

if (($hash && $syspasswd) && $hash eq $syspasswd) {
      if (defined($opts{'stdin'})) {
        # Cannot prompt again if automated.  Simply print an error message
        # and exit.
        print STDOUT "$program: error: password matches system password\n";

# Restore the file permissions.
        unless (chmod(0440, $output_file)) {
          print STDERR "$program: unable to set permissions on $output_file: $!";
        }

exit 4;

} else {
        print STDOUT "Please use a password that is different from your system password.\n";
        return get_passwd(name => $name);
      }
    }
  }

return "" if ($args{'allow_blank'} and $passwd eq "");

# check for BAD passwords, BLANK passwords, etc, if requested
  if (defined($opts{'use-cracklib'})) {
    require Crypt::Cracklib;
    if (!Crypt::Cracklib::check($passwd, $cracklib_dict)) {
      print STDOUT "Bad password: ", Crypt::Cracklib::fascist_check($passwd,
        $cracklib_dict), "\n";
      return get_passwd(name => $name);
    }
  }

my $salt = get_salt();

my $hash = crypt($passwd, $salt);

# Check that the crypt() implementation properly supports use of the MD5
  # (or other non-DES algorithm), if specified.
  if (!defined($opts{'des'})) {
    if (defined($opts{'md5'})) {
      # if the first three characters of the hash are not "$1$", the crypt()
      # implementation doesn't support MD5.  Some crypt()s will happily use
      # "$1" as a salt even though this is not a valid DES salt.  Humf.
      #
      # Perl doesn't treat strings as arrays of characters, so extracting the
      # first three characters is a little more convoluted (I'm accustomed to
      # C's strncmp(3) for this now).

my @string = split('', $hash);
      my $prefix = $string[0] . $string[1] . $string[2];

if ($prefix ne '$1$') { 
        print STDOUT "You requested MD5 passwords but your system does not support it.  Defaulting to DES passwords.\n\n";
      }

} elsif (defined($opts{'sha256'})) {
      # if the first three characters of the hash are not "$5$", the crypt()
      # implementation doesn't support SHA-256.  Some crypt()s will happily use
      # "$5" as a salt even though this is not a valid DES salt.  Humf.
      #
      # Perl doesn't treat strings as arrays of characters, so extracting the
      # first three characters is a little more convoluted (I'm accustomed to
      # C's strncmp(3) for this now).

my @string = split('', $hash);
      my $prefix = $string[0] . $string[1] . $string[2];

if ($prefix ne '$5$') {
        print STDOUT "You requested SHA-256 passwords but your system does not support it.  Defaulting to DES passwords.\n\n";
      }

} elsif (defined($opts{'sha512'})) {
      # if the first three characters of the hash are not "$6$", the crypt()
      # implementation doesn't support SHA-512.  Some crypt()s will happily use
      # "$6" as a salt even though this is not a valid DES salt.  Humf.
      #
      # Perl doesn't treat strings as arrays of characters, so extracting the
      # first three characters is a little more convoluted (I'm accustomed to
      # C's strncmp(3) for this now).

my @string = split('', $hash);
      my $prefix = $string[0] . $string[1] . $string[2];

if ($prefix ne '$6$') {
        print STDOUT "You requested SHA-512 passwords but your system does not support it.  Defaulting to DES passwords.\n\n";
      }
    }
  }

return $hash;
}

# ----------------------------------------------------------------------------
sub get_syspasswd {
  my %args = @_;

my $user = $args{'user'};

# test the shadow password support on this system.  Some systems, such
  # as the BSDs, use "transparent shadowing", where the real passwd will
  # be returned via getpwnam() only if the process has root privs (effective
  # UID of zero).  That check has already been performed.  However, other
  # systems still may not return the password via getpwnam() (such as Linux).
  # These other systems use a shadow password library of functions, and require
  # other work to retrieve the password.  On these systems, the retrieved
  # password will be "x".

my $syspasswd = (getpwnam($user))[1];

if ($syspasswd eq "" || $syspasswd eq "x")  {

# do the retrieval the hard way: open up /etc/shadow and iterate
    # through each line.  Yuck.  *sigh*.  Thanks to Micah Anderson
    # for working out this issue.

open(SHADOW, "< /etc/shadow") or
      die "$program: unable to access shadow file: $!\n";

while (chomp(my $line = <SHADOW>)) {
      next unless $line =~ /^$user/;
      $syspasswd = (split(':', $line))[1];
      last; 
    }
    close(SHADOW);

# if the password is still "x", you have problems 
    if ($syspasswd eq "x") {
      die "$program: unable to retrieve shadow password.\nContact your system
administrator.\n";
    }
  }

return $syspasswd;
}

# ----------------------------------------------------------------------------
sub handle_group_entry {
  my %args = @_;

my $gid = $args{'gid'};
  my $name = $args{'name'};
  my $delete_group = $args{'delete_group'};
  my $delete_user = $args{'delete_user'};
  my $add_user = $args{'add_user'};
  my $passwd;

my $members = "";
  $members = join(',', @{$args{'members'}}) if (defined($args{'members'}));

# check to see whether we should update the fields for this group (because
  # it already exists), or to create a new entry

my $found = 0;
  my $index = 0;
  for ($index = 0; $index <= $#data; $index++) {
    my @entry = split(':', $data[$index]);

if ($name eq $entry[0]) {
      $found = 1;

# If we have not been given an explicit password, reuse the existing one.
      $passwd = $entry[1] unless $passwd;

# If we have not been given an explicit GID, reuse the existing one.
      $gid = $entry[2] unless $gid;

# If we have not been given explicit members, reuse the existing ones.
      $members = $entry[3] if $members eq '';

last;
    }
  }

unless ($found) {
    print STDOUT "$program: creating group entry for group $name\n";

} else {
    print STDOUT "$program: updating group entry for group $name\n";
  }

# if present, add the members given to the group.  If none, just leave that
  # field blank

# prompt for the group password, if requested
  if (defined($opts{'enable-group-passwd'})) {
    $passwd = get_passwd(name => $name, allow_blank => 1);

} else {
    $passwd = "x";
  }

# remove the entry to be updated
  splice(@data, $index, 1);

if ($delete_group) {
    print STDOUT "$program: entry deleted\n";
    return;
  }

if ($delete_user) {
    $members =~ s/$delete_user//g;
    $members =~ s/,,/,/g;
    $members =~ s/^,//g;
    $members =~ s/,$//g;
  }

if ($add_user) {
    if (length($members) > 0) {
      $members .= ",$add_user";

} else {
      $members = $add_user;
    }
  }

# Ensure that we have a sorted list of unique members
  my $uniq_members = { map { $_ => 1 } split(',', $members) };
  my $names = join(',', sort { $a <=> $b } keys(%$uniq_members));

# format: $name:$passwd:$gid:$members
  push(@data, "$name:$passwd:$gid:$names");

# always sort by GIDs before printing out the file
  @data = map { $_->[0] }
          sort {
                $a->[3] <=> $b->[3]
               }
          map { [ $_, (split /:/)[0, 1, 2, 3] ] }
          @data;

if ($delete_group) {
    print STDOUT "$program: entry deleted\n";

} elsif ($found) {
    print STDOUT "$program: entry updated\n";

} else {
    print STDOUT "$program: entry created\n";
  }
}

# ----------------------------------------------------------------------------
sub handle_passwd_entry {
  my %args = @_;

my $name = $args{'name'};
  my $uid = $args{'uid'};
  my $gid = $args{'gid'};
  my $gecos = $args{'gecos'};
  my $home = $args{'home'};
  my $shell = $args{'shell'};
  my $delete_user = $args{'delete_user'};
  my $new_passwd = $args{'new_passwd'};

# Trim any trailing slashes in $home.
  $home =~ s/(.*)\/$/$1/ if ($home =~ /\/$/);

# Make sure the given home directory is NOT a relative path (what a
  # horrible idea).
 
  unless ($home =~ /^\//) {
    print STDOUT "$program: error: relative path given for home directory\n";
    exit 8;
  }
  
  # check to see whether we should update the fields for this user (because
  # they already exist), or create a new entry

my $found = 0;
  my $index = 0;
  for ($index = 0; $index <= $#data; $index++) {
    my @entry = split(':', $data[$index]);

if ($name eq $entry[0]) {
      $found = 1;
      last;
    }
  }

unless ($found) {
    print STDOUT "$program: creating passwd entry for user $name\n";

} else {
    print STDOUT "$program: updating passwd entry for user $name\n";
  }

my $passwd;

if (!$delete_user) {
    if (!$new_passwd) {
      # check the requested shell against the list in /etc/shells
      check_shell(shell => $shell);

# prompt the user for the password
      $passwd = get_passwd(name => $name);

} else {
      $passwd = $new_passwd;
    }
  }

# remove the entry to be updated
  splice(@data, $index, 1);

if ($delete_user) {
    print STDOUT "$program: entry deleted\n";
    return;
  }

# format: $name:$passwd:$uid:$gid:$gecos:$home:$shell
  push(@data, "$name:$passwd:$uid:$gid:$gecos:$home:$shell");

# always sort by UIDs before printing out the file
  @data = map { $_->[0] }
          sort {
                $a->[3] <=> $b->[3]
               }
          map { [ $_, (split /:/)[0, 1, 2, 3, 4, 5, 6] ] }
          @data;

if ($delete_user) {
    print STDOUT "$program: entry deleted\n";

} elsif ($found) {
    print STDOUT "$program: entry updated\n";

} else {
    print STDOUT "$program: entry created\n";
  }
}

# ----------------------------------------------------------------------------
sub open_output_file {
  my %args = @_;

# open $output_file, paying attention to the --force command-line option
  # If the file already exists, slurp up its contents for later updating.

if (-f $output_file) {
    # make sure we can write/update the file first
    unless (chmod(0644, $output_file)) {
      die "$program: unable to set permissions on $output_file to 0644: $!\n";
    }

if (open(my $fh, "< $output_file")) {
      if (flock($fh, LOCK_SH|LOCK_NB)) {
        chomp(@data = <$fh>);
        flock($fh, LOCK_UN);
        close($fh);

} else {
        close($fh);
        die("$program: unable to read $output_file: Locked (in use) by another process\n");
      }

} else {
      die("$program: unable to open $output_file: $!\n");
    }
  }

# if the --force option was given, just zero out any data that might have
  # been read in, effectively erasing whatever contents there were.  A new
  # file is generated, anyway -- it's just a question of what data goes into
  # it

@data = () if (defined($opts{'F'}));
}

# ----------------------------------------------------------------------------
sub usage {

print STDOUT <<END_OF_USAGE;

usage: $program [--help] [--hash|--group|--passwd]

REQUIRED: --passwd, --group, or --hash.  These specify whether $program is to
  operate on a passwd(5) format file, on a group(5) format file, or simply
  to generate a password hash, respectively.

If used with --passwd, $program creates a file in the passwd(5) format,
  suitable for use with proftpd's AuthUserFile configuration directive.
  You will be prompted for the password to use of the user, which will be
  encrypted, and written out as the encrypted string.  New entries are
  appended to the file by default.
 
  By default, using --passwd will write output to "$default_passwd_file".

Error exit values:

To make it easier for wrapper scripts to interact with $program, $program
  will exit with the following error values for the reasons described:

1       no such user
    2       password matches current password
    4       password matches system password
    8       relative path given for home directory

Options:

--file      Write output to specified file, rather than "$default_passwd_file".

-F          If the file to be used already exists, delete it and write a
    --force     new one.  By default, new entries will be appended to the file.

--gecos     Descriptive string for the given user (usually the user's
                full name).

--gid       Primary group ID for this user (optional, will default to
                given --uid value if absent).

-h          Displays this message.
    --help

--home      Home directory for the user (required).

--des       Use the DES algorithm for encrypting passwords.  The default
                is the MD5 algorithm.

--md5       Use the MD5 algorithm for encrypting passwords.  This is the
                default.

--name      Name of the user account (required).  If the name does not
                exist in the specified output-file, an entry will be created
                for her.  Otherwise, the given fields will be updated.

--shell     Shell for the user (required).  Recommended: /bin/false

--uid       Numerical user ID (required)

--change-home

Update only the home directory field for a user.  This option
                requires that the --name and --passwd options be used, but no
                others.

--change-password

Update only the password field for a user.  This option
                requires that the --name and --passwd options be used, but
                no others.  This also double-checks the given password against
                the user's current password in the existing passwd file, and
                requests that a new password be given if the entered password
                is the same as the current password.

--delete-user
 
                Remove the entry for the given user name from the file.

-l          Lock the password of the named account.  This option disables a
    --lock      password by changing it to a value which matches no possible
                encrypted value (it adds a '!' at the beginning of the
                password).

--not-previous-password

Double-checks the given password against the previous password
                for the user, and requests that a new password be given if
                the entered password is the same as the previous password.

--not-system-password

Double-checks the given password against the system password
                for the user, and requests that a new password be given if
                the entered password is the same as the system password.  This
                helps to enforce different passwords for different types of
                access.

--sha256    Use the SHA-256 algorithm for encrypting passwords.

--sha512    Use the SHA-512 algorithm for encrypting passwords.

--stdin
                Read the password directly from standard in rather than
                prompting for it.  This is useful for writing scripts that
                automate use of $program.

-u          Unlock the password of the named account.  This option
    --unlock    re-enables a password by changing the password back to its
                previous value (to the value before using the -l option).

--use-cracklib

Causes $program to use Alec Muffet's cracklib routines in
                order to determine and prevent the use of bad or weak
                passwords.  The optional path to this option specifies
                the path to the dictionary files to use -- default path
                is "$default_cracklib_dict".  This requires the Perl
                Crypt::Cracklib module to be installed on your system.

--version
                Displays the version of $program.

If used with --group, $program creates a file in the group(5) format,
  suitable for use with proftpd's AuthGroupFile configuration directive.

By default, using --group will write output to "$default_group_file".

Options:

--add-member

Add the named member to the given group name from the file.
                Example:

\$ ftpasswd --group --file=... --name=ftpd --add-member=bob

--delete-group

Remove the entry for the given group name from the file.

--enable-group-passwd

Prompt for a group password.  This is disabled by default,
                as group passwords are not usually a good idea at all.

--file      Write output to specified file, rather than "$default_group_file".

-F          If the file be used already exists, delete it and write a new
    --force     one.  By default, new entries will be appended to the file.

--gid       Numerical group ID (required).

-h
    --help      Displays this message.

-m
    --member    User name to be a member of the group.  This argument may be
                used multiple times to specify the full list of users to be
                members of this group.

--des       Use the DES algorithm for encrypting passwords.  The default
                is the MD5 algorithm.

--md5       Use the MD5 algorithm for encrypting passwords.  This is the
                default.

--name      Name of the group (required).  If the name does not exist in
                the specified output-file, an entry will be created for them.
                Otherwise, the given fields will be updated.

--sha256    Use the SHA-256 algorithm for encrypting passwords.

--sha512    Use the SHA-512 algorithm for encrypting passwords.

--stdin
                Read the password directly from standard in rather than
                prompting for it.  This is useful for writing scripts that
                automate use of $program.

--use-cracklib

--version
                Displays the version of $program.

If used with --hash, $program generates a hash of a password, as would
  appear in an AuthUserFile.  The hash is written to standard out.
  This hash is suitable for use with proftpd's UserPassword directive.

Options:

--des       Use the DES algorithm for encrypting passwords.  The default
                is the MD5 algorithm.

--md5       Use the MD5 algorithm for encrypting passwords.  This is the
                default.

--sha256    Use the SHA-256 algorithm for encrypting passwords.

--sha512    Use the SHA-512 algorithm for encrypting passwords.

--stdin
                Read the password directly from standard in rather than
                prompting for it.  This is useful for writing scripts that
                automate use of $program.

--use-cracklib

--version
                Displays the version of $program.

END_OF_USAGE

exit 0;
}

# ---------------------------------------------------------------------------
sub version {
  print STDOUT "$version\n";

exit 0;
}

# ---------------------------------------------------------------------------

${this.title}

Code Editor : ftpasswd