import nfc

def on_connect(tag):
    print(f"Tag type : {tag.type}")
    print(f"UID      : {tag.identifier.hex().upper()}")
    if hasattr(tag, 'atq'):
        print(f"ATQA     : {tag.atq.hex().upper()}")
    if hasattr(tag, 'sak'):
        print(f"SAK      : {tag.sak:02X}")
    return False  # release tag immediately

with nfc.ContactlessFrontend('usb') as clf:
    print("Hold a tag near the reader...")
    clf.connect(rdwr={'on-connect': on_connect})

import nfc

KEY_A = bytearray.fromhex('FFFFFFFFFFFF')  # factory default

def on_connect(tag):
    if tag.type != 'MifareClassic':
        print("Not a MIFARE Classic tag")
        return False
    sector = 0
    block  = 1
    try:
        tag.authenticate(block, KEY_A, b'\x60')   # 0x60 = key A
        data = tag.read(block)
        print(f"Block {block}: {data.hex()}")
    except nfc.tag.TagCommandError as e:
        print(f"Error: {e}")
    return False

with nfc.ContactlessFrontend('usb') as clf:
    clf.connect(rdwr={'on-connect': on_connect})

import nfc

COMMON_KEYS = [
    bytes.fromhex('FFFFFFFFFFFF'),
    bytes.fromhex('A0A1A2A3A4A5'),
    bytes.fromhex('D3F7D3F7D3F7'),
    bytes.fromhex('000000000000'),
    bytes.fromhex('B0B1B2B3B4B5'),
]

def try_read_sector(tag, sector, keys):
    first_block = sector * 4
    for key in keys:
        for key_type, code in [(bytearray(key), b'\x60'),
                                (bytearray(key), b'\x61')]:
            try:
                tag.authenticate(first_block, key_type, code)
                blocks = [tag.read(first_block + i).hex()
                          for i in range(4)]
                return blocks, key.hex(), 'A' if code == b'\x60' else 'B'
            except Exception:
                continue
    return None, None, None

def on_connect(tag):
    if tag.type != 'MifareClassic':
        return False
    print(f"UID: {tag.identifier.hex()}")
    for sector in range(16):
        blocks, key, key_id = try_read_sector(tag, sector, COMMON_KEYS)
        if blocks:
            print(f"Sector {sector:2d} (Key {key_id}={key}):")
            for i, b in enumerate(blocks):
                print(f"  Block {sector*4+i}: {b}")
        else:
            print(f"Sector {sector:2d}: LOCKED (no matching key found)")
    return False

with nfc.ContactlessFrontend('usb') as clf:
    clf.connect(rdwr={'on-connect': on_connect})

import nfc

def on_connect(tag):
    if not tag.ndef:
        print("No NDEF data found (tag may not be NDEF-formatted)")
        return False
    print(f"NDEF version  : {tag.ndef.version}")
    print(f"NDEF capacity : {tag.ndef.capacity} bytes")
    print(f"NDEF length   : {tag.ndef.length} bytes")
    print(f"Writeable     : {tag.ndef.is_writeable}")
    print()
    for i, record in enumerate(tag.ndef.records):
        print(f"Record {i}: {record}")
    return False

with nfc.ContactlessFrontend('usb') as clf:
    clf.connect(rdwr={'on-connect': on_connect})

import nfc, ndef

TARGET_URL = "https://example.com"

def on_connect(tag):
    if tag.ndef is None:
        print("Tag is not NDEF-formatted. Attempting format...")
        tag.format()
    records = [ndef.UriRecord(TARGET_URL)]
    tag.ndef.records = records
    print(f"Wrote NDEF URI: {TARGET_URL}")
    return False

with nfc.ContactlessFrontend('usb') as clf:
    clf.connect(rdwr={'on-connect': on_connect})

import nfc, ndef

def on_connect(tag):
    if tag.type != 'MifareClassic':
        return False
    mad_key = bytearray.fromhex('A0A1A2A3A4A5')
    ndef_key = bytearray.fromhex('D3F7D3F7D3F7')
    # Format creates MAD with default keys
    tag.format(wipe=0x00)
    records = [ndef.UriRecord("https://example.com")]
    tag.ndef.records = records
    print("NDEF written to MIFARE Classic via MAD")
    return False

with nfc.ContactlessFrontend('usb') as clf:
    clf.connect(rdwr={'on-connect': on_connect})

import nfc

def on_connect(tag):
    if tag.type != 'Type2Tag':
        return False
    print(f"UID: {tag.identifier.hex()}")
    # Type2Tag exposes read(page) returning 16 bytes (4 pages)
    for page in range(0, 45, 4):
        data = tag.read(page)
        for i in range(4):
            offset = i * 4
            row = page + i
            print(f"  Page {row:3d}: {data[offset:offset+4].hex()}")
    return False

with nfc.ContactlessFrontend('usb') as clf:
    clf.connect(rdwr={'on-connect': on_connect})

from smartcard.System import readers
from smartcard.util import toHexString, toBytes

r = readers()
if not r:
    print("No readers found")
    exit()

print(f"Using reader: {r[0]}")
conn = r[0].createConnection()
conn.connect()

# ACR122U GET UID pseudo-APDU
get_uid = [0xFF, 0xCA, 0x00, 0x00, 0x00]
data, sw1, sw2 = conn.transmit(get_uid)
if sw1 == 0x90:
    print(f"UID: {toHexString(data)}")
else:
    print(f"Error: SW={sw1:02X}{sw2:02X}")
conn.disconnect()

import ndef

# Build a multi-record Smart Poster: URL + title
records = [
    ndef.SmartposterRecord(
        resource="https://example.com",
        title=[("en", "Example website"), ("fr", "Site exemple")],
        action="open",
    )
]
encoded = b"".join(ndef.message_encoder(records))
print(f"Encoded ({len(encoded)} bytes): {encoded.hex()}")

# Parse back
for record in ndef.message_decoder(encoded):
    print(f"Type: {type(record).__name__}")
    print(f"  URI: {record.resource}")
    for lang, text in record.title:
        print(f"  Title [{lang}]: {text}")