ida-domain 0.3.6.dev2__tar.gz → 0.3.6.dev3__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (29) hide show
  1. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/PKG-INFO +1 -1
  2. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/__init__.py +1 -1
  3. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/functions.py +1 -1
  4. ida_domain-0.3.6.dev3/ida_domain/py.typed +0 -0
  5. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/types.py +1065 -1
  6. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain.egg-info/PKG-INFO +1 -1
  7. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain.egg-info/SOURCES.txt +1 -0
  8. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/pyproject.toml +1 -1
  9. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/LICENSE +0 -0
  10. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/README.md +0 -0
  11. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/base.py +0 -0
  12. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/bytes.py +0 -0
  13. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/comments.py +0 -0
  14. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/database.py +0 -0
  15. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/entries.py +0 -0
  16. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/flowchart.py +0 -0
  17. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/heads.py +0 -0
  18. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/hooks.py +0 -0
  19. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/instructions.py +0 -0
  20. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/names.py +0 -0
  21. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/operands.py +0 -0
  22. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/segments.py +0 -0
  23. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/signature_files.py +0 -0
  24. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/strings.py +0 -0
  25. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/xrefs.py +0 -0
  26. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain.egg-info/dependency_links.txt +0 -0
  27. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain.egg-info/requires.txt +0 -0
  28. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain.egg-info/top_level.txt +0 -0
  29. {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/setup.cfg +0 -0
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.4
2
2
  Name: ida-domain
3
- Version: 0.3.6.dev2
3
+ Version: 0.3.6.dev3
4
4
  Summary: IDA Domain API - Python interface for IDA Pro reverse engineering platform
5
5
  Author-email: Hex-Rays SA <support@hex-rays.com>
6
6
  License-Expression: MIT
@@ -25,7 +25,7 @@ def _load_dependencies() -> None:
25
25
  import idapro
26
26
 
27
27
 
28
- __version__ = '0.3.6-dev.2'
28
+ __version__ = '0.3.6-dev.3'
29
29
 
30
30
  # Make sure all dependencies are loaded
31
31
  _load_dependencies()
@@ -649,7 +649,7 @@ class Functions(DatabaseEntity):
649
649
  """
650
650
  return ida_domain.flowchart.FlowChart(self.database, func, None, flags)
651
651
 
652
- def get_instructions(self, func: func_t) -> Optional[Iterator[insn_t]]:
652
+ def get_instructions(self, func: func_t) -> Iterator[insn_t]:
653
653
  """
654
654
  Retrieves all instructions within the given function.
655
655
 
File without changes
@@ -2,22 +2,34 @@ from __future__ import annotations
2
2
 
3
3
  import logging
4
4
  import warnings
5
+ from dataclasses import dataclass
5
6
  from enum import Enum, EnumMeta, Flag, IntEnum, IntFlag, auto
6
7
  from pathlib import Path
7
8
 
8
9
  import ida_nalt
9
10
  import ida_typeinf
10
11
  from ida_typeinf import (
12
+ BT_FLOAT,
13
+ BT_INT8,
14
+ BT_INT16,
15
+ BT_INT32,
16
+ BT_INT64,
17
+ BT_VOID,
18
+ BTF_STRUCT,
19
+ BTF_UNION,
20
+ BTMT_DOUBLE,
11
21
  array_type_data_t,
12
22
  bitfield_type_data_t,
13
23
  enum_type_data_t,
14
24
  func_type_data_t,
25
+ funcarg_t,
15
26
  ptr_type_data_t,
16
27
  til_t,
17
28
  tinfo_t,
29
+ udm_t,
18
30
  udt_type_data_t,
19
31
  )
20
- from typing_extensions import TYPE_CHECKING, Callable, Dict, Iterator, Optional, Tuple
32
+ from typing_extensions import TYPE_CHECKING, Callable, Dict, Iterator, List, Optional, Tuple, Union
21
33
 
22
34
  from . import __ida_version__
23
35
  from .base import (
@@ -867,6 +879,477 @@ class TypeDetailsVisitor(ida_typeinf.tinfo_visitor_t):
867
879
  return 0
868
880
 
869
881
 
882
+ # =============================================================================
883
+ # Member Information Dataclasses
884
+ # =============================================================================
885
+
886
+
887
+ @dataclass
888
+ class UdtMemberInfo:
889
+ """Details about a struct/union member."""
890
+
891
+ name: str
892
+ """Member name."""
893
+
894
+ type: tinfo_t
895
+ """Member type information."""
896
+
897
+ offset: int
898
+ """Byte offset within the structure."""
899
+
900
+ size: int
901
+ """Size in bytes."""
902
+
903
+ is_bitfield: bool
904
+ """True if this is a bitfield member."""
905
+
906
+ bit_offset: Optional[int] = None
907
+ """Bit offset within the byte (for bitfields only)."""
908
+
909
+ bit_size: Optional[int] = None
910
+ """Bit size (for bitfields only)."""
911
+
912
+
913
+ @dataclass
914
+ class EnumMemberInfo:
915
+ """Details about an enum member."""
916
+
917
+ name: str
918
+ """Member name."""
919
+
920
+ value: int
921
+ """Numeric value."""
922
+
923
+
924
+ @dataclass
925
+ class FuncArgumentInfo:
926
+ """Details about a function argument."""
927
+
928
+ index: int
929
+ """Argument index (0-based)."""
930
+
931
+ name: str
932
+ """Argument name (may be empty/auto-generated)."""
933
+
934
+ type: tinfo_t
935
+ """Argument type information."""
936
+
937
+
938
+ # =============================================================================
939
+ # Type Member Lookup Mode
940
+ # =============================================================================
941
+
942
+
943
+ class TypeMemberLookupMode(Enum):
944
+ """Mode for member lookup operations."""
945
+
946
+ NAME = "name"
947
+ """Look up member by name"""
948
+
949
+ OFFSET = "offset"
950
+ """Look up member by offset (for UDT)"""
951
+
952
+ INDEX = "index"
953
+ """Look up member by index (for enum, func args)"""
954
+
955
+ VALUE = "value"
956
+ """Look up member by value (for enum)"""
957
+
958
+
959
+ # =============================================================================
960
+ # Calling Convention Enum
961
+ # =============================================================================
962
+
963
+
964
+ class CallingConvention(Enum):
965
+ """Calling convention for function types."""
966
+
967
+ CDECL = "cdecl"
968
+ STDCALL = "stdcall"
969
+ FASTCALL = "fastcall"
970
+ THISCALL = "thiscall"
971
+ DEFAULT = "default"
972
+
973
+
974
+ # =============================================================================
975
+ # Type Builders
976
+ # =============================================================================
977
+
978
+
979
+ class StructBuilder:
980
+ """
981
+ Builder for creating struct types.
982
+
983
+ Example:
984
+ >>> builder = db.types.create_struct("MyStruct")
985
+ >>> builder.add_member("x", db.types.create_primitive(4))
986
+ >>> builder.add_member("y", db.types.create_primitive(4))
987
+ >>> my_struct = builder.build()
988
+ """
989
+
990
+ def __init__(self, name: str) -> None:
991
+ """
992
+ Initialize a struct builder.
993
+
994
+ Args:
995
+ name: Name for the struct type.
996
+ """
997
+ self._name = name
998
+ self._members: List[Tuple[str, tinfo_t, Optional[int]]] = []
999
+ self._packed = False
1000
+ self._alignment: Optional[int] = None
1001
+
1002
+ def add_member(
1003
+ self,
1004
+ name: str,
1005
+ member_type: tinfo_t,
1006
+ offset: Optional[int] = None
1007
+ ) -> 'StructBuilder':
1008
+ """
1009
+ Add a member to the struct.
1010
+
1011
+ Args:
1012
+ name: Member name.
1013
+ member_type: Member type.
1014
+ offset: Explicit byte offset (auto-calculated if None).
1015
+
1016
+ Returns:
1017
+ Self for method chaining.
1018
+ """
1019
+ self._members.append((name, member_type, offset))
1020
+ return self
1021
+
1022
+ def set_packed(self, packed: bool = True) -> 'StructBuilder':
1023
+ """
1024
+ Set whether the struct is packed (no padding).
1025
+ """
1026
+ self._packed = packed
1027
+ return self
1028
+
1029
+ def set_alignment(self, alignment: int) -> 'StructBuilder':
1030
+ """
1031
+ Set explicit alignment for the struct.
1032
+ """
1033
+ self._alignment = alignment
1034
+ return self
1035
+
1036
+ def build(self) -> tinfo_t:
1037
+ """
1038
+ Build and return the struct type.
1039
+
1040
+ Returns:
1041
+ The constructed tinfo_t.
1042
+
1043
+ Raises:
1044
+ RuntimeError: If struct creation fails.
1045
+ """
1046
+ udt = udt_type_data_t()
1047
+ udt.is_union = False
1048
+
1049
+ for name, member_type, offset in self._members:
1050
+ if offset is not None:
1051
+ udt_member = udt.add_member(name, member_type, offset)
1052
+ else:
1053
+ udt_member = udt.add_member(name, member_type)
1054
+ if udt_member is None:
1055
+ raise RuntimeError(f"Failed to add member '{name}' to struct '{self._name}'")
1056
+
1057
+ result = tinfo_t()
1058
+ if not result.create_udt(udt, BTF_STRUCT):
1059
+ raise RuntimeError(f"Failed to create struct '{self._name}'")
1060
+
1061
+ return result
1062
+
1063
+ def build_and_save(self, library: Optional[til_t] = None) -> tinfo_t:
1064
+ """
1065
+ Build the struct and save it to a type library.
1066
+
1067
+ Args:
1068
+ library: Target library (local library if None).
1069
+
1070
+ Returns:
1071
+ The constructed and saved tinfo_t.
1072
+ """
1073
+ result = self.build()
1074
+ if library is None:
1075
+ library = ida_typeinf.get_idati()
1076
+ if result.set_named_type(library, self._name) < 0:
1077
+ raise RuntimeError(f"Failed to save struct '{self._name}' to library")
1078
+ return result
1079
+
1080
+
1081
+ class UnionBuilder:
1082
+ """
1083
+ Builder for creating union types.
1084
+
1085
+ Example:
1086
+ >>> builder = db.types.create_union("MyUnion")
1087
+ >>> builder.add_member("as_int", db.types.create_primitive(4))
1088
+ >>> builder.add_member("as_float", db.types.create_primitive(4))
1089
+ >>> my_union = builder.build()
1090
+ """
1091
+
1092
+ def __init__(self, name: str) -> None:
1093
+ """
1094
+ Initialize a union builder.
1095
+
1096
+ Args:
1097
+ name: Name for the union type.
1098
+ """
1099
+ self._name = name
1100
+ self._members: List[Tuple[str, tinfo_t]] = []
1101
+
1102
+ def add_member(self, name: str, member_type: tinfo_t) -> 'UnionBuilder':
1103
+ """
1104
+ Add a member to the union.
1105
+
1106
+ Args:
1107
+ name: Member name.
1108
+ member_type: Member type.
1109
+
1110
+ Returns:
1111
+ Self for method chaining.
1112
+ """
1113
+ self._members.append((name, member_type))
1114
+ return self
1115
+
1116
+ def build(self) -> tinfo_t:
1117
+ """
1118
+ Build and return the union type.
1119
+
1120
+ Returns:
1121
+ The constructed tinfo_t.
1122
+
1123
+ Raises:
1124
+ RuntimeError: If union creation fails.
1125
+ """
1126
+ udt = udt_type_data_t()
1127
+ udt.is_union = True
1128
+
1129
+ for name, member_type in self._members:
1130
+ udt_member = udt.add_member(name, member_type)
1131
+ if udt_member is None:
1132
+ raise RuntimeError(f"Failed to add member '{name}' to union '{self._name}'")
1133
+
1134
+ result = tinfo_t()
1135
+ if not result.create_udt(udt, BTF_UNION):
1136
+ raise RuntimeError(f"Failed to create union '{self._name}'")
1137
+
1138
+ return result
1139
+
1140
+ def build_and_save(self, library: Optional[til_t] = None) -> tinfo_t:
1141
+ """
1142
+ Build the union and save it to a type library.
1143
+
1144
+ Args:
1145
+ library: Target library (local library if None).
1146
+
1147
+ Returns:
1148
+ The constructed and saved tinfo_t.
1149
+ """
1150
+ result = self.build()
1151
+ if library is None:
1152
+ library = ida_typeinf.get_idati()
1153
+ if result.set_named_type(library, self._name) < 0:
1154
+ raise RuntimeError(f"Failed to save union '{self._name}' to library")
1155
+ return result
1156
+
1157
+
1158
+ class EnumBuilder:
1159
+ """
1160
+ Builder for creating enum types.
1161
+
1162
+ Example:
1163
+ >>> builder = db.types.create_enum("FileMode", base_size=4)
1164
+ >>> builder.add_member("READ", 1)
1165
+ >>> builder.add_member("WRITE", 2)
1166
+ >>> builder.add_member("EXEC", 4)
1167
+ >>> file_mode = builder.build()
1168
+ """
1169
+
1170
+ def __init__(self, name: str, base_size: int = 4) -> None:
1171
+ """
1172
+ Initialize an enum builder.
1173
+
1174
+ Args:
1175
+ name: Name for the enum type.
1176
+ base_size: Size in bytes (1, 2, 4, or 8).
1177
+ """
1178
+ self._name = name
1179
+ self._base_size = base_size
1180
+ self._members: List[Tuple[str, int]] = []
1181
+ self._is_bitmask = False
1182
+
1183
+ def add_member(self, name: str, value: int) -> 'EnumBuilder':
1184
+ """
1185
+ Add a member to the enum.
1186
+
1187
+ Args:
1188
+ name: Member name.
1189
+ value: Numeric value.
1190
+
1191
+ Returns:
1192
+ Self for method chaining.
1193
+ """
1194
+ self._members.append((name, value))
1195
+ return self
1196
+
1197
+ def set_bitmask(self, is_bitmask: bool = True) -> 'EnumBuilder':
1198
+ """
1199
+ Set whether this is a bitmask enum.
1200
+ """
1201
+ self._is_bitmask = is_bitmask
1202
+ return self
1203
+
1204
+ def build(self) -> tinfo_t:
1205
+ """
1206
+ Build and return the enum type.
1207
+
1208
+ Returns:
1209
+ The constructed tinfo_t.
1210
+
1211
+ Raises:
1212
+ RuntimeError: If enum creation fails.
1213
+ """
1214
+ enum_data = enum_type_data_t()
1215
+
1216
+ for name, value in self._members:
1217
+ enum_data.add_constant(name, value)
1218
+
1219
+ if self._is_bitmask:
1220
+ enum_data.set_bf(True)
1221
+
1222
+ result = tinfo_t()
1223
+ if not result.create_enum(enum_data):
1224
+ raise RuntimeError(f"Failed to create enum '{self._name}'")
1225
+
1226
+ return result
1227
+
1228
+ def build_and_save(self, library: Optional[til_t] = None) -> tinfo_t:
1229
+ """
1230
+ Build the enum and save it to a type library.
1231
+
1232
+ Args:
1233
+ library: Target library (local library if None).
1234
+
1235
+ Returns:
1236
+ The constructed and saved tinfo_t.
1237
+ """
1238
+ result = self.build()
1239
+ if library is None:
1240
+ library = ida_typeinf.get_idati()
1241
+ if result.set_named_type(library, self._name) < 0:
1242
+ raise RuntimeError(f"Failed to save enum '{self._name}' to library")
1243
+ return result
1244
+
1245
+
1246
+ class FuncTypeBuilder:
1247
+ """
1248
+ Builder for creating function types.
1249
+
1250
+ Example:
1251
+ >>> builder = db.types.create_func_type()
1252
+ >>> builder.set_return_type(db.types.create_primitive(4))
1253
+ >>> builder.add_argument("count", db.types.create_primitive(4))
1254
+ >>> builder.add_argument("buffer", db.types.create_pointer(db.types.create_primitive(1)))
1255
+ >>> func_type = builder.build()
1256
+ """
1257
+
1258
+ def __init__(self) -> None:
1259
+ """Initialize a function type builder."""
1260
+ self._return_type: Optional[tinfo_t] = None
1261
+ self._arguments: List[Tuple[str, tinfo_t]] = []
1262
+ self._calling_convention: Optional[CallingConvention] = None
1263
+ self._variadic = False
1264
+
1265
+ def set_return_type(self, ret_type: tinfo_t) -> 'FuncTypeBuilder':
1266
+ """
1267
+ Set the return type.
1268
+
1269
+ Args:
1270
+ ret_type: Return type (void if not set).
1271
+
1272
+ Returns:
1273
+ Self for method chaining.
1274
+ """
1275
+ self._return_type = ret_type
1276
+ return self
1277
+
1278
+ def add_argument(
1279
+ self,
1280
+ name: str,
1281
+ arg_type: tinfo_t
1282
+ ) -> 'FuncTypeBuilder':
1283
+ """
1284
+ Add an argument to the function type.
1285
+
1286
+ Args:
1287
+ name: Argument name.
1288
+ arg_type: Argument type.
1289
+
1290
+ Returns:
1291
+ Self for method chaining.
1292
+ """
1293
+ self._arguments.append((name, arg_type))
1294
+ return self
1295
+
1296
+ def set_calling_convention(self, cc: CallingConvention) -> 'FuncTypeBuilder':
1297
+ """
1298
+ Set the calling convention.
1299
+
1300
+ Args:
1301
+ cc: Calling convention enum value.
1302
+
1303
+ Returns:
1304
+ Self for method chaining.
1305
+ """
1306
+ self._calling_convention = cc
1307
+ return self
1308
+
1309
+ def set_variadic(self, variadic: bool = True) -> 'FuncTypeBuilder':
1310
+ """
1311
+ Set whether function accepts variable arguments.
1312
+
1313
+ Returns:
1314
+ Self for method chaining.
1315
+ """
1316
+ self._variadic = variadic
1317
+ return self
1318
+
1319
+ def build(self) -> tinfo_t:
1320
+ """
1321
+ Build and return the function type.
1322
+
1323
+ Returns:
1324
+ The constructed tinfo_t.
1325
+
1326
+ Raises:
1327
+ RuntimeError: If function type creation fails.
1328
+ """
1329
+ ftd = func_type_data_t()
1330
+
1331
+ # Set return type
1332
+ if self._return_type is not None:
1333
+ ftd.rettype = self._return_type
1334
+ else:
1335
+ void_type = tinfo_t()
1336
+ void_type.create_simple_type(BT_VOID)
1337
+ ftd.rettype = void_type
1338
+
1339
+ # Add arguments
1340
+ for name, arg_type in self._arguments:
1341
+ fa = funcarg_t()
1342
+ fa.name = name
1343
+ fa.type = arg_type
1344
+ ftd.push_back(fa)
1345
+
1346
+ result = tinfo_t()
1347
+ if not result.create_func(ftd):
1348
+ raise RuntimeError("Failed to create function type")
1349
+
1350
+ return result
1351
+
1352
+
870
1353
  @decorate_all_methods(check_db_open)
871
1354
  class Types(DatabaseEntity):
872
1355
  """
@@ -1234,3 +1717,584 @@ class Types(DatabaseEntity):
1234
1717
  Comment text, or empty string if no comment exists.
1235
1718
  """
1236
1719
  return type_info.get_type_cmt() or ''
1720
+
1721
+ # =========================================================================
1722
+ # UDT (Struct/Union) Member Access
1723
+ # =========================================================================
1724
+
1725
+ def get_udt_members(self, type_info: tinfo_t) -> Iterator[UdtMemberInfo]:
1726
+ """
1727
+ Iterate over all members of a struct or union type.
1728
+
1729
+ Args:
1730
+ type_info: A UDT (struct or union) type.
1731
+
1732
+ Returns:
1733
+ Iterator of UdtMemberInfo for each member.
1734
+ Empty iterator if type is not a UDT.
1735
+
1736
+ Example:
1737
+ >>> struct_type = db.types.get_by_name("MyStruct")
1738
+ >>> for member in db.types.get_udt_members(struct_type):
1739
+ ... print(f"{member.name}: {member.size} bytes at offset {member.offset}")
1740
+ """
1741
+ if not type_info.is_udt():
1742
+ return
1743
+
1744
+ udt_data = udt_type_data_t()
1745
+ if not type_info.get_udt_details(udt_data):
1746
+ return
1747
+
1748
+ for member in udt_data:
1749
+ m: udm_t = member
1750
+ byte_offset = int(m.offset) // 8 # Offsets are in bits
1751
+ is_bitfield = m.type.is_bitfield()
1752
+
1753
+ bit_offset = None
1754
+ bit_size = None
1755
+ if is_bitfield:
1756
+ bit_offset = int(m.offset) % 8
1757
+ bit_size = m.size
1758
+
1759
+ yield UdtMemberInfo(
1760
+ name=m.name,
1761
+ type=m.type,
1762
+ offset=byte_offset,
1763
+ size=m.type.get_size(),
1764
+ is_bitfield=is_bitfield,
1765
+ bit_offset=bit_offset,
1766
+ bit_size=bit_size,
1767
+ )
1768
+
1769
+ def get_udt_member_by_name(
1770
+ self, type_info: tinfo_t, name: str
1771
+ ) -> Optional[UdtMemberInfo]:
1772
+ """
1773
+ Get a specific UDT member by name.
1774
+
1775
+ Args:
1776
+ type_info: A UDT (struct or union) type.
1777
+ name: Member name to find.
1778
+
1779
+ Returns:
1780
+ UdtMemberInfo if found, None otherwise.
1781
+ """
1782
+ for member in self.get_udt_members(type_info):
1783
+ if member.name == name:
1784
+ return member
1785
+ return None
1786
+
1787
+ def get_udt_member_by_offset(
1788
+ self, type_info: tinfo_t, offset: int
1789
+ ) -> Optional[UdtMemberInfo]:
1790
+ """
1791
+ Get a UDT member at the specified byte offset.
1792
+
1793
+ Args:
1794
+ type_info: A UDT (struct or union) type.
1795
+ offset: Byte offset within the structure.
1796
+
1797
+ Returns:
1798
+ UdtMemberInfo if found, None otherwise.
1799
+ """
1800
+ for member in self.get_udt_members(type_info):
1801
+ if member.offset == offset:
1802
+ return member
1803
+ return None
1804
+
1805
+ def get_udt_member_count(self, type_info: tinfo_t) -> int:
1806
+ """
1807
+ Get the number of members in a UDT.
1808
+
1809
+ Args:
1810
+ type_info: A UDT type.
1811
+
1812
+ Returns:
1813
+ Member count, or 0 if not a UDT.
1814
+ """
1815
+ if not type_info.is_udt():
1816
+ return 0
1817
+ return type_info.get_udt_nmembers()
1818
+
1819
+ # =========================================================================
1820
+ # Enum Member Access
1821
+ # =========================================================================
1822
+
1823
+ def get_enum_members(self, type_info: tinfo_t) -> Iterator[EnumMemberInfo]:
1824
+ """
1825
+ Iterate over all members of an enum type.
1826
+
1827
+ Args:
1828
+ type_info: An enum type.
1829
+
1830
+ Returns:
1831
+ Iterator of EnumMemberInfo for each member.
1832
+ Empty iterator if type is not an enum.
1833
+
1834
+ Example:
1835
+ >>> enum_type = db.types.get_by_name("FileMode")
1836
+ >>> for member in db.types.get_enum_members(enum_type):
1837
+ ... print(f"{member.name} = {member.value}")
1838
+ """
1839
+ if not type_info.is_enum():
1840
+ return
1841
+
1842
+ for e in type_info.iter_enum():
1843
+ yield EnumMemberInfo(name=e.name, value=e.value)
1844
+
1845
+ def get_enum_member_by_name(
1846
+ self, type_info: tinfo_t, name: str
1847
+ ) -> Optional[EnumMemberInfo]:
1848
+ """
1849
+ Get a specific enum member by name.
1850
+
1851
+ Args:
1852
+ type_info: An enum type.
1853
+ name: Member name to find.
1854
+
1855
+ Returns:
1856
+ EnumMemberInfo if found, None otherwise.
1857
+ """
1858
+ for member in self.get_enum_members(type_info):
1859
+ if member.name == name:
1860
+ return member
1861
+ return None
1862
+
1863
+ def get_enum_member_by_value(
1864
+ self, type_info: tinfo_t, value: int
1865
+ ) -> Optional[EnumMemberInfo]:
1866
+ """
1867
+ Get a specific enum member by value.
1868
+
1869
+ Args:
1870
+ type_info: An enum type.
1871
+ value: Numeric value to find.
1872
+
1873
+ Returns:
1874
+ EnumMemberInfo if found, None otherwise.
1875
+ """
1876
+ for member in self.get_enum_members(type_info):
1877
+ if member.value == value:
1878
+ return member
1879
+ return None
1880
+
1881
+ def get_enum_member_count(self, type_info: tinfo_t) -> int:
1882
+ """
1883
+ Get the number of members in an enum.
1884
+
1885
+ Args:
1886
+ type_info: An enum type.
1887
+
1888
+ Returns:
1889
+ Member count, or 0 if not an enum.
1890
+ """
1891
+ if not type_info.is_enum():
1892
+ return 0
1893
+
1894
+ enum_data = enum_type_data_t()
1895
+ if type_info.get_enum_details(enum_data):
1896
+ return enum_data.size()
1897
+ return 0
1898
+
1899
+ # =========================================================================
1900
+ # Function Type Access
1901
+ # =========================================================================
1902
+
1903
+ def get_func_arguments(self, type_info: tinfo_t) -> Iterator[FuncArgumentInfo]:
1904
+ """
1905
+ Iterate over all arguments of a function type.
1906
+
1907
+ Args:
1908
+ type_info: A function type.
1909
+
1910
+ Returns:
1911
+ Iterator of FuncArgumentInfo for each argument.
1912
+ Empty iterator if type is not a function.
1913
+
1914
+ Example:
1915
+ >>> func_type = db.types.get_at(0x401000)
1916
+ >>> for arg in db.types.get_func_arguments(func_type):
1917
+ ... print(f"Arg {arg.index}: {arg.name}")
1918
+ """
1919
+ if not type_info.is_func():
1920
+ return
1921
+
1922
+ for i, arg in enumerate(type_info.iter_func()):
1923
+ arg_name = arg.name if arg.name else f"arg{i}"
1924
+ yield FuncArgumentInfo(index=i, name=arg_name, type=arg.type)
1925
+
1926
+ def get_func_argument_by_index(
1927
+ self, type_info: tinfo_t, index: int
1928
+ ) -> Optional[FuncArgumentInfo]:
1929
+ """
1930
+ Get a specific function argument by index.
1931
+
1932
+ Args:
1933
+ type_info: A function type.
1934
+ index: Argument index (0-based).
1935
+
1936
+ Returns:
1937
+ FuncArgumentInfo if found, None otherwise.
1938
+ """
1939
+ for arg in self.get_func_arguments(type_info):
1940
+ if arg.index == index:
1941
+ return arg
1942
+ return None
1943
+
1944
+ def get_func_argument_count(self, type_info: tinfo_t) -> int:
1945
+ """
1946
+ Get the number of arguments in a function type.
1947
+
1948
+ Args:
1949
+ type_info: A function type.
1950
+
1951
+ Returns:
1952
+ Argument count, or 0 if not a function type.
1953
+ """
1954
+ if not type_info.is_func():
1955
+ return 0
1956
+
1957
+ func_data = func_type_data_t()
1958
+ if type_info.get_func_details(func_data):
1959
+ return len(func_data)
1960
+ return 0
1961
+
1962
+ def get_return_type(self, type_info: tinfo_t) -> Optional[tinfo_t]:
1963
+ """
1964
+ Get the return type of a function type.
1965
+
1966
+ Args:
1967
+ type_info: A function type.
1968
+
1969
+ Returns:
1970
+ The return type, or None if not a function type.
1971
+ """
1972
+ if not type_info.is_func():
1973
+ return None
1974
+ return type_info.get_rettype()
1975
+
1976
+ # =========================================================================
1977
+ # Pointer/Array Type Access
1978
+ # =========================================================================
1979
+
1980
+ def get_pointed_type(self, type_info: tinfo_t) -> Optional[tinfo_t]:
1981
+ """
1982
+ Get the type pointed to by a pointer type.
1983
+
1984
+ Args:
1985
+ type_info: A pointer type.
1986
+
1987
+ Returns:
1988
+ The pointed-to type, or None if not a pointer.
1989
+
1990
+ Example:
1991
+ >>> ptr_type = db.types.get_at(0x401000) # char*
1992
+ >>> base = db.types.get_pointed_type(ptr_type) # char
1993
+ """
1994
+ if not type_info.is_ptr() and not type_info.is_funcptr():
1995
+ return None
1996
+ return type_info.get_pointed_object()
1997
+
1998
+ def get_array_element_type(self, type_info: tinfo_t) -> Optional[tinfo_t]:
1999
+ """
2000
+ Get the element type of an array type.
2001
+
2002
+ Args:
2003
+ type_info: An array type.
2004
+
2005
+ Returns:
2006
+ The element type, or None if not an array.
2007
+ """
2008
+ if not type_info.is_array():
2009
+ return None
2010
+
2011
+ array_data = array_type_data_t()
2012
+ if type_info.get_array_details(array_data):
2013
+ return array_data.elem_type
2014
+ return None
2015
+
2016
+ def get_array_length(self, type_info: tinfo_t) -> Optional[int]:
2017
+ """
2018
+ Get the number of elements in an array type.
2019
+
2020
+ Args:
2021
+ type_info: An array type.
2022
+
2023
+ Returns:
2024
+ The array length, or None if not an array.
2025
+ """
2026
+ if not type_info.is_array():
2027
+ return None
2028
+
2029
+ array_data = array_type_data_t()
2030
+ if type_info.get_array_details(array_data):
2031
+ return array_data.nelems
2032
+ return None
2033
+
2034
+ # =========================================================================
2035
+ # Type Creation Methods
2036
+ # =========================================================================
2037
+
2038
+ def create_void(self) -> tinfo_t:
2039
+ """
2040
+ Create a void type.
2041
+
2042
+ Returns:
2043
+ A void tinfo_t.
2044
+ """
2045
+ result = tinfo_t()
2046
+ result.create_simple_type(BT_VOID)
2047
+ return result
2048
+
2049
+ def create_primitive(self, size: int, signed: bool = True) -> tinfo_t:
2050
+ """
2051
+ Create a primitive integer type.
2052
+
2053
+ Args:
2054
+ size: Size in bytes (1, 2, 4, or 8).
2055
+ signed: True for signed, False for unsigned.
2056
+
2057
+ Returns:
2058
+ The primitive type.
2059
+
2060
+ Raises:
2061
+ InvalidParameterError: If size is not 1, 2, 4, or 8.
2062
+
2063
+ Example:
2064
+ >>> int32 = db.types.create_primitive(4, signed=True)
2065
+ >>> uint8 = db.types.create_primitive(1, signed=False)
2066
+ """
2067
+ size_to_type = {
2068
+ 1: BT_INT8,
2069
+ 2: BT_INT16,
2070
+ 4: BT_INT32,
2071
+ 8: BT_INT64,
2072
+ }
2073
+
2074
+ if size not in size_to_type:
2075
+ raise InvalidParameterError("size", size, "must be 1, 2, 4, or 8")
2076
+
2077
+ result = tinfo_t()
2078
+ result.create_simple_type(size_to_type[size])
2079
+ return result
2080
+
2081
+ def create_float(self, size: int = 4) -> tinfo_t:
2082
+ """
2083
+ Create a floating-point type.
2084
+
2085
+ Args:
2086
+ size: 4 for float, 8 for double.
2087
+
2088
+ Returns:
2089
+ The floating-point type.
2090
+
2091
+ Raises:
2092
+ InvalidParameterError: If size is not 4 or 8.
2093
+ """
2094
+ if size == 4:
2095
+ result = tinfo_t()
2096
+ result.create_simple_type(BT_FLOAT)
2097
+ return result
2098
+ elif size == 8:
2099
+ result = tinfo_t()
2100
+ result.create_simple_type(BT_FLOAT | BTMT_DOUBLE)
2101
+ return result
2102
+ else:
2103
+ raise InvalidParameterError("size", size, "must be 4 or 8")
2104
+
2105
+ def create_pointer(self, target: tinfo_t) -> tinfo_t:
2106
+ """
2107
+ Create a pointer type.
2108
+
2109
+ Args:
2110
+ target: The type being pointed to.
2111
+
2112
+ Returns:
2113
+ A pointer to the target type.
2114
+
2115
+ Example:
2116
+ >>> char_type = db.types.create_primitive(1)
2117
+ >>> char_ptr = db.types.create_pointer(char_type)
2118
+ """
2119
+ result = tinfo_t()
2120
+ result.create_ptr(target)
2121
+ return result
2122
+
2123
+ def create_array(self, element_type: tinfo_t, count: int) -> tinfo_t:
2124
+ """
2125
+ Create an array type.
2126
+
2127
+ Args:
2128
+ element_type: Type of array elements.
2129
+ count: Number of elements.
2130
+
2131
+ Returns:
2132
+ The array type.
2133
+
2134
+ Example:
2135
+ >>> char_type = db.types.create_primitive(1)
2136
+ >>> buffer = db.types.create_array(char_type, 256)
2137
+ """
2138
+ array_data = array_type_data_t()
2139
+ array_data.elem_type = element_type
2140
+ array_data.nelems = count
2141
+ array_data.base = 0
2142
+
2143
+ result = tinfo_t()
2144
+ result.create_array(array_data)
2145
+ return result
2146
+
2147
+ # =========================================================================
2148
+ # Builder Factory Methods
2149
+ # =========================================================================
2150
+
2151
+ def create_struct(self, name: str) -> StructBuilder:
2152
+ """
2153
+ Create a struct builder.
2154
+
2155
+ Args:
2156
+ name: Name for the struct.
2157
+
2158
+ Returns:
2159
+ A StructBuilder for constructing the type.
2160
+
2161
+ Example:
2162
+ >>> point = db.types.create_struct("Point") \\
2163
+ ... .add_member("x", db.types.create_primitive(4)) \\
2164
+ ... .add_member("y", db.types.create_primitive(4)) \\
2165
+ ... .build()
2166
+ """
2167
+ return StructBuilder(name)
2168
+
2169
+ def create_union(self, name: str) -> UnionBuilder:
2170
+ """
2171
+ Create a union builder.
2172
+
2173
+ Args:
2174
+ name: Name for the union.
2175
+
2176
+ Returns:
2177
+ A UnionBuilder for constructing the type.
2178
+ """
2179
+ return UnionBuilder(name)
2180
+
2181
+ def create_enum(self, name: str, base_size: int = 4) -> EnumBuilder:
2182
+ """
2183
+ Create an enum builder.
2184
+
2185
+ Args:
2186
+ name: Name for the enum.
2187
+ base_size: Underlying integer size (1, 2, 4, or 8).
2188
+
2189
+ Returns:
2190
+ An EnumBuilder for constructing the type.
2191
+ """
2192
+ return EnumBuilder(name, base_size)
2193
+
2194
+ def create_func_type(self) -> FuncTypeBuilder:
2195
+ """
2196
+ Create a function type builder.
2197
+
2198
+ Returns:
2199
+ A FuncTypeBuilder for constructing the type.
2200
+ """
2201
+ return FuncTypeBuilder()
2202
+
2203
+ # =========================================================================
2204
+ # Unified LLM-Friendly Interface
2205
+ # =========================================================================
2206
+
2207
+ def get_member(
2208
+ self,
2209
+ type_info: tinfo_t,
2210
+ key: Union[str, int],
2211
+ by: Union[TypeMemberLookupMode, str] = TypeMemberLookupMode.NAME
2212
+ ) -> Optional[Union[UdtMemberInfo, EnumMemberInfo, FuncArgumentInfo]]:
2213
+ """
2214
+ Get a type member (LLM-friendly unified interface).
2215
+
2216
+ Works for struct/union members, enum members, and function arguments.
2217
+
2218
+ Args:
2219
+ type_info: The type to inspect.
2220
+ key: Lookup key (name, offset, index, or value depending on 'by').
2221
+ by: Lookup mode:
2222
+ - "name": Look up by member/argument name
2223
+ - "offset": Look up by byte offset (UDT only)
2224
+ - "index": Look up by index (enum, func args)
2225
+ - "value": Look up by enum value (enum only)
2226
+
2227
+ Returns:
2228
+ The member info if found, None otherwise.
2229
+
2230
+ Example:
2231
+ >>> # Get struct member by name
2232
+ >>> member = db.types.get_member(struct_type, "x", by="name")
2233
+ >>> # Get struct member by offset
2234
+ >>> member = db.types.get_member(struct_type, 4, by="offset")
2235
+ >>> # Get function argument by index
2236
+ >>> arg = db.types.get_member(func_type, 0, by="index")
2237
+ """
2238
+ # Normalize mode
2239
+ if isinstance(by, str):
2240
+ by = TypeMemberLookupMode(by)
2241
+
2242
+ if by == TypeMemberLookupMode.NAME:
2243
+ if not isinstance(key, str):
2244
+ raise InvalidParameterError("key", key, "must be a string when by='name'")
2245
+ if type_info.is_udt():
2246
+ return self.get_udt_member_by_name(type_info, key)
2247
+ elif type_info.is_enum():
2248
+ return self.get_enum_member_by_name(type_info, key)
2249
+ # Function arguments don't typically have meaningful names to search by
2250
+ return None
2251
+
2252
+ elif by == TypeMemberLookupMode.OFFSET:
2253
+ if not isinstance(key, int):
2254
+ raise InvalidParameterError("key", key, "must be an int when by='offset'")
2255
+ if type_info.is_udt():
2256
+ return self.get_udt_member_by_offset(type_info, key)
2257
+ return None
2258
+
2259
+ elif by == TypeMemberLookupMode.INDEX:
2260
+ if not isinstance(key, int):
2261
+ raise InvalidParameterError("key", key, "must be an int when by='index'")
2262
+ if type_info.is_func():
2263
+ return self.get_func_argument_by_index(type_info, key)
2264
+ return None
2265
+
2266
+ elif by == TypeMemberLookupMode.VALUE:
2267
+ if not isinstance(key, int):
2268
+ raise InvalidParameterError("key", key, "must be an int when by='value'")
2269
+ if type_info.is_enum():
2270
+ return self.get_enum_member_by_value(type_info, key)
2271
+ return None
2272
+
2273
+ return None
2274
+
2275
+ def get_members(
2276
+ self,
2277
+ type_info: tinfo_t
2278
+ ) -> Iterator[Union[UdtMemberInfo, EnumMemberInfo, FuncArgumentInfo]]:
2279
+ """
2280
+ Get all members of a type (LLM-friendly unified interface).
2281
+
2282
+ Works for struct/union types, enum types, and function types.
2283
+
2284
+ Args:
2285
+ type_info: The type to inspect.
2286
+
2287
+ Returns:
2288
+ Iterator of member info objects.
2289
+ Empty iterator if type has no members.
2290
+
2291
+ Example:
2292
+ >>> for member in db.types.get_members(struct_type):
2293
+ ... print(f"{member.name}")
2294
+ """
2295
+ if type_info.is_udt():
2296
+ yield from self.get_udt_members(type_info)
2297
+ elif type_info.is_enum():
2298
+ yield from self.get_enum_members(type_info)
2299
+ elif type_info.is_func():
2300
+ yield from self.get_func_arguments(type_info)
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.4
2
2
  Name: ida-domain
3
- Version: 0.3.6.dev2
3
+ Version: 0.3.6.dev3
4
4
  Summary: IDA Domain API - Python interface for IDA Pro reverse engineering platform
5
5
  Author-email: Hex-Rays SA <support@hex-rays.com>
6
6
  License-Expression: MIT
@@ -14,6 +14,7 @@ ida_domain/hooks.py
14
14
  ida_domain/instructions.py
15
15
  ida_domain/names.py
16
16
  ida_domain/operands.py
17
+ ida_domain/py.typed
17
18
  ida_domain/segments.py
18
19
  ida_domain/signature_files.py
19
20
  ida_domain/strings.py
@@ -1,6 +1,6 @@
1
1
  [project]
2
2
  name = "ida-domain"
3
- version = "0.3.6-dev.2"
3
+ version = "0.3.6-dev.3"
4
4
  description = "IDA Domain API - Python interface for IDA Pro reverse engineering platform"
5
5
  requires-python = ">=3.9"
6
6
  license = "MIT"
File without changes